@tomdraper/claude-usage 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Tom Draper
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,50 @@
+<p align="center">
+  <h1 align="center">Claude Usage</h1>
+</p>
+
+<p align="center">
+  <code>npx @tomdraper/claude-usage</code>
+</p>
+
+<img width="1303" height="957" alt="Claude-Usage-05-14-2026_07_47_AM" src="https://github.com/user-attachments/assets/699fc000-daca-4bfd-b85f-f7fe492eeac2" />
+
+<br>
+<br>
+
+Claude Code stores detailed session data locally on your machine. Claude Usage reads these JSONL logs and launches a powerful, filter-first dashboard for exploring your usage. 100% local, no data leaves your machine.
+
+## Installation
+
+Run without installing:
+
+```sh
+npx @tomdraper/claude-usage
+```
+
+Or install globally:
+
+```sh
+npm install -g @tomdraper/claude-usage
+claude-usage
+```
+
+## Estimations
+
+Estimated (proportional token-share distribution across each day's activity)
+- Per-model messages
+- Per-model sessions
+- Per-model costs, when the stats cache reports zero cost for a model (falls back to API pricing tables)
+
+Model cost estimates are calculated using Anthropic API pricing. Actual costs for Pro, Max, and Teams users are typically far lower, since subscription usage is heavily subsidized.
+
+These are estimated rather than read directly from JSONL files because older sessions may not include fields like `model`, `gitBranch`, `entrypoint`, or `cwd`, making JSONL-derived counts unreliable across full history. The stats cache has accurate totals going further back, so per-model figures are derived by distributing each day's totals proportionally by token share.
+
+## Contributions
+
+Contributions, issues and feature requests are welcome.
+
+- Fork it (https://github.com/tom-draper/claude-usage)
+- Create your feature branch (`git checkout -b my-new-feature`)
+- Commit your changes (`git commit -am 'Add some feature'`)
+- Push to the branch (`git push origin my-new-feature`)
+- Create a new Pull Request

package/bin/claude-usage.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+"use strict";
+require("../dist/cli/index.js");

package/dist/cli/index.js

@@ -0,0 +1,591 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/cli/index.ts
+var import_http = __toESM(require("http"));
+var import_fs2 = __toESM(require("fs"));
+var import_path2 = __toESM(require("path"));
+var import_child_process = require("child_process");
+
+// src/cli/parser.ts
+var import_fs = __toESM(require("fs"));
+var import_path = __toESM(require("path"));
+var import_os = __toESM(require("os"));
+var import_readline = __toESM(require("readline"));
+var CLAUDE_DIR = import_path.default.join(import_os.default.homedir(), ".claude");
+var STATS_CACHE = import_path.default.join(CLAUDE_DIR, "stats-cache.json");
+var PROJECTS_DIR = import_path.default.join(CLAUDE_DIR, "projects");
+function readStatsCache() {
+  try {
+    return JSON.parse(import_fs.default.readFileSync(STATS_CACHE, "utf8"));
+  } catch {
+    throw new Error(
+      `No stats cache found at ${STATS_CACHE}. Make sure Claude Code has been used on this machine.`
+    );
+  }
+}
+var MODEL_PRICING = [
+  { match: (id) => /opus-4/.test(id), inputPerMToken: 15, outputPerMToken: 75, cacheWritePerMToken: 18.75, cacheReadPerMToken: 1.5 },
+  { match: (id) => /sonnet-4|3-5-sonnet|sonnet-3-5/.test(id), inputPerMToken: 3, outputPerMToken: 15, cacheWritePerMToken: 3.75, cacheReadPerMToken: 0.3 },
+  { match: (id) => /haiku-4|haiku-3-5|3-5-haiku/.test(id), inputPerMToken: 0.8, outputPerMToken: 4, cacheWritePerMToken: 1, cacheReadPerMToken: 0.08 },
+  { match: (id) => /opus-3|3-opus/.test(id), inputPerMToken: 15, outputPerMToken: 75, cacheWritePerMToken: 18.75, cacheReadPerMToken: 1.5 },
+  { match: (id) => /sonnet-3|3-sonnet/.test(id), inputPerMToken: 3, outputPerMToken: 15, cacheWritePerMToken: 3.75, cacheReadPerMToken: 0.3 },
+  { match: (id) => /haiku-3|3-haiku/.test(id), inputPerMToken: 0.25, outputPerMToken: 1.25, cacheWritePerMToken: 0.3, cacheReadPerMToken: 0.03 }
+];
+function estimateCost(id, inputTokens, outputTokens, cacheReadTokens, cacheCreateTokens) {
+  const p = MODEL_PRICING.find((m) => m.match(id));
+  if (!p) return 0;
+  return inputTokens * p.inputPerMToken / 1e6 + outputTokens * p.outputPerMToken / 1e6 + cacheCreateTokens * p.cacheWritePerMToken / 1e6 + cacheReadTokens * p.cacheReadPerMToken / 1e6;
+}
+function formatModelName(id) {
+  const stripped = id.startsWith("claude-") ? id.slice(7) : id;
+  const match = stripped.match(/^(sonnet|opus|haiku)-(\d+)-(\d+)/);
+  if (match) {
+    const [, family, major, minor] = match;
+    return `${family.charAt(0).toUpperCase() + family.slice(1)} ${major}.${minor}`;
+  }
+  return stripped.charAt(0).toUpperCase() + stripped.slice(1);
+}
+async function getCwdFromJsonl(filePath) {
+  return new Promise((resolve) => {
+    let resolved = false;
+    const done = (val) => {
+      if (!resolved) {
+        resolved = true;
+        resolve(val);
+      }
+    };
+    let stream;
+    try {
+      stream = import_fs.default.createReadStream(filePath, { encoding: "utf8" });
+    } catch {
+      return done(null);
+    }
+    const rl = import_readline.default.createInterface({ input: stream, crlfDelay: Infinity });
+    let lineCount = 0;
+    rl.on("line", (line) => {
+      lineCount++;
+      if (lineCount > 20) {
+        rl.close();
+        return;
+      }
+      try {
+        const obj = JSON.parse(line);
+        if (obj.cwd) {
+          done(obj.cwd);
+          rl.close();
+        }
+      } catch {
+      }
+    });
+    rl.on("close", () => done(null));
+    stream.on("error", () => done(null));
+  });
+}
+function parseJSONLFiles() {
+  const result = {
+    modelMessages: {},
+    modelSessionCounts: {},
+    modelToolCalls: {},
+    modelToolNames: {},
+    modelThinkingTurns: {},
+    stopReasons: {},
+    stopReasonHourlyCounts: {},
+    stopReasonDailyCounts: {},
+    stopReasonMiniutelyCounts: {},
+    entrypoints: {},
+    entrypointHourlyCounts: {},
+    entrypointDailyCounts: {},
+    entrypointMiniutelyCounts: {},
+    branchCounts: {},
+    branchHourlyCounts: {},
+    branchDailyCounts: {},
+    branchMiniutelyCounts: {},
+    branchSessionCounts: {},
+    toolCounts: {},
+    toolHourlyCounts: {},
+    toolDailyCounts: {},
+    toolMiniutelyCounts: {},
+    hourlyMessages: {},
+    hourlyModelTokens: {},
+    hourlySessionCounts: {},
+    minutelyMessages: {},
+    minutelyModelTokens: {},
+    projectDailyMessages: {},
+    projectHourlyMessages: {},
+    modelStopReasons: {},
+    modelBranchSessions: {},
+    modelProjectSessions: {},
+    toolStopReasons: {},
+    toolBranchSessions: {},
+    toolProjectSessions: {},
+    toolSessionCounts: {},
+    stopReasonBranchSessions: {},
+    stopReasonProjectSessions: {},
+    stopReasonSessionCounts: {},
+    branchProjectSessions: {}
+  };
+  const inc = (map, key) => {
+    map[key] = (map[key] ?? 0) + 1;
+  };
+  let dirEntries;
+  try {
+    dirEntries = import_fs.default.readdirSync(PROJECTS_DIR, { withFileTypes: true });
+  } catch {
+    return result;
+  }
+  for (const dir of dirEntries) {
+    if (!dir.isDirectory()) continue;
+    const dirPath = import_path.default.join(PROJECTS_DIR, dir.name);
+    let files;
+    try {
+      files = import_fs.default.readdirSync(dirPath).filter((f) => f.endsWith(".jsonl"));
+    } catch {
+      continue;
+    }
+    for (const file of files) {
+      let content;
+      try {
+        content = import_fs.default.readFileSync(import_path.default.join(dirPath, file), "utf8");
+      } catch {
+        continue;
+      }
+      let firstUserHour = null;
+      const branchesInSession = /* @__PURE__ */ new Set();
+      const cwdsInSession = /* @__PURE__ */ new Set();
+      const modelsInSession = /* @__PURE__ */ new Set();
+      const toolsInSession = /* @__PURE__ */ new Set();
+      const stopReasonsInSession = /* @__PURE__ */ new Set();
+      for (const line of content.split("\n")) {
+        if (!line.trim()) continue;
+        let obj;
+        try {
+          obj = JSON.parse(line);
+        } catch {
+          continue;
+        }
+        if (obj.type === "assistant") {
+          const msg = obj.message;
+          const model = msg?.model;
+          const ts = obj.timestamp;
+          const toolsInMessage = /* @__PURE__ */ new Set();
+          if (model) {
+            inc(result.modelMessages, model);
+            modelsInSession.add(model);
+            let hasThinking = false;
+            for (const block of msg?.content ?? []) {
+              if (block.type === "tool_use") {
+                inc(result.modelToolCalls, model);
+                if (block.name) {
+                  inc(result.toolCounts, block.name);
+                  toolsInMessage.add(block.name);
+                  toolsInSession.add(block.name);
+                  if (!result.modelToolNames[model]) result.modelToolNames[model] = {};
+                  inc(result.modelToolNames[model], block.name);
+                  if (ts) {
+                    if (!result.toolHourlyCounts[block.name]) result.toolHourlyCounts[block.name] = {};
+                    inc(result.toolHourlyCounts[block.name], ts.slice(0, 13));
+                    if (!result.toolDailyCounts[block.name]) result.toolDailyCounts[block.name] = {};
+                    inc(result.toolDailyCounts[block.name], ts.slice(0, 10));
+                    if (!result.toolMiniutelyCounts[block.name]) result.toolMiniutelyCounts[block.name] = {};
+                    inc(result.toolMiniutelyCounts[block.name], ts.slice(0, 16));
+                  }
+                }
+              }
+              if (block.type === "thinking") hasThinking = true;
+            }
+            if (hasThinking) inc(result.modelThinkingTurns, model);
+            const usage = msg?.usage;
+            if (ts && usage) {
+              const tokens = (usage.input_tokens ?? 0) + (usage.output_tokens ?? 0) + (usage.cache_read_input_tokens ?? 0) + (usage.cache_creation_input_tokens ?? 0);
+              const hour = ts.slice(0, 13);
+              if (!result.hourlyModelTokens[model]) result.hourlyModelTokens[model] = {};
+              result.hourlyModelTokens[model][hour] = (result.hourlyModelTokens[model][hour] ?? 0) + tokens;
+              const minute = ts.slice(0, 16);
+              if (!result.minutelyModelTokens[model]) result.minutelyModelTokens[model] = {};
+              result.minutelyModelTokens[model][minute] = (result.minutelyModelTokens[model][minute] ?? 0) + tokens;
+            }
+          }
+          if (msg?.stop_reason) {
+            const reason = msg.stop_reason;
+            inc(result.stopReasons, reason);
+            stopReasonsInSession.add(reason);
+            if (model) {
+              if (!result.modelStopReasons[model]) result.modelStopReasons[model] = {};
+              inc(result.modelStopReasons[model], reason);
+            }
+            for (const toolName of toolsInMessage) {
+              if (!result.toolStopReasons[toolName]) result.toolStopReasons[toolName] = {};
+              inc(result.toolStopReasons[toolName], reason);
+            }
+            if (ts) {
+              const hour = ts.slice(0, 13);
+              const day = ts.slice(0, 10);
+              const minute = ts.slice(0, 16);
+              if (!result.stopReasonHourlyCounts[reason]) result.stopReasonHourlyCounts[reason] = {};
+              inc(result.stopReasonHourlyCounts[reason], hour);
+              if (!result.stopReasonDailyCounts[reason]) result.stopReasonDailyCounts[reason] = {};
+              inc(result.stopReasonDailyCounts[reason], day);
+              if (!result.stopReasonMiniutelyCounts[reason]) result.stopReasonMiniutelyCounts[reason] = {};
+              inc(result.stopReasonMiniutelyCounts[reason], minute);
+            }
+          }
+        } else if (obj.type === "user") {
+          if (obj.entrypoint) {
+            const ep = obj.entrypoint;
+            inc(result.entrypoints, ep);
+            const ts2 = obj.timestamp;
+            if (ts2) {
+              const hour = ts2.slice(0, 13);
+              const day = ts2.slice(0, 10);
+              const minute = ts2.slice(0, 16);
+              if (!result.entrypointHourlyCounts[ep]) result.entrypointHourlyCounts[ep] = {};
+              inc(result.entrypointHourlyCounts[ep], hour);
+              if (!result.entrypointDailyCounts[ep]) result.entrypointDailyCounts[ep] = {};
+              inc(result.entrypointDailyCounts[ep], day);
+              if (!result.entrypointMiniutelyCounts[ep]) result.entrypointMiniutelyCounts[ep] = {};
+              inc(result.entrypointMiniutelyCounts[ep], minute);
+            }
+          }
+          if (obj.gitBranch) {
+            const branch = obj.gitBranch;
+            inc(result.branchCounts, branch);
+            branchesInSession.add(branch);
+            const bts = obj.timestamp;
+            if (bts) {
+              if (!result.branchHourlyCounts[branch]) result.branchHourlyCounts[branch] = {};
+              inc(result.branchHourlyCounts[branch], bts.slice(0, 13));
+              if (!result.branchDailyCounts[branch]) result.branchDailyCounts[branch] = {};
+              inc(result.branchDailyCounts[branch], bts.slice(0, 10));
+              if (!result.branchMiniutelyCounts[branch]) result.branchMiniutelyCounts[branch] = {};
+              inc(result.branchMiniutelyCounts[branch], bts.slice(0, 16));
+            }
+          }
+          const ts = obj.timestamp;
+          if (ts) {
+            if (!firstUserHour) firstUserHour = ts.slice(0, 13);
+            inc(result.hourlyMessages, ts.slice(0, 13));
+            inc(result.minutelyMessages, ts.slice(0, 16));
+            const cwd = obj.cwd;
+            if (cwd) {
+              cwdsInSession.add(cwd);
+              const date = ts.slice(0, 10);
+              const hour = ts.slice(0, 13);
+              if (!result.projectDailyMessages[cwd]) result.projectDailyMessages[cwd] = {};
+              inc(result.projectDailyMessages[cwd], date);
+              if (!result.projectHourlyMessages[cwd]) result.projectHourlyMessages[cwd] = {};
+              inc(result.projectHourlyMessages[cwd], hour);
+            }
+          }
+        }
+      }
+      if (firstUserHour) {
+        result.hourlySessionCounts[firstUserHour] = (result.hourlySessionCounts[firstUserHour] ?? 0) + 1;
+      }
+      for (const branch of branchesInSession) {
+        result.branchSessionCounts[branch] = (result.branchSessionCounts[branch] ?? 0) + 1;
+        for (const cwd of cwdsInSession) {
+          if (!result.branchProjectSessions[branch]) result.branchProjectSessions[branch] = {};
+          result.branchProjectSessions[branch][cwd] = (result.branchProjectSessions[branch][cwd] ?? 0) + 1;
+        }
+      }
+      for (const model of modelsInSession) {
+        result.modelSessionCounts[model] = (result.modelSessionCounts[model] ?? 0) + 1;
+        for (const branch of branchesInSession) {
+          if (!result.modelBranchSessions[model]) result.modelBranchSessions[model] = {};
+          result.modelBranchSessions[model][branch] = (result.modelBranchSessions[model][branch] ?? 0) + 1;
+        }
+        for (const cwd of cwdsInSession) {
+          if (!result.modelProjectSessions[model]) result.modelProjectSessions[model] = {};
+          result.modelProjectSessions[model][cwd] = (result.modelProjectSessions[model][cwd] ?? 0) + 1;
+        }
+      }
+      for (const tool of toolsInSession) {
+        result.toolSessionCounts[tool] = (result.toolSessionCounts[tool] ?? 0) + 1;
+        for (const branch of branchesInSession) {
+          if (!result.toolBranchSessions[tool]) result.toolBranchSessions[tool] = {};
+          result.toolBranchSessions[tool][branch] = (result.toolBranchSessions[tool][branch] ?? 0) + 1;
+        }
+        for (const cwd of cwdsInSession) {
+          if (!result.toolProjectSessions[tool]) result.toolProjectSessions[tool] = {};
+          result.toolProjectSessions[tool][cwd] = (result.toolProjectSessions[tool][cwd] ?? 0) + 1;
+        }
+      }
+      for (const reason of stopReasonsInSession) {
+        result.stopReasonSessionCounts[reason] = (result.stopReasonSessionCounts[reason] ?? 0) + 1;
+        for (const branch of branchesInSession) {
+          if (!result.stopReasonBranchSessions[reason]) result.stopReasonBranchSessions[reason] = {};
+          result.stopReasonBranchSessions[reason][branch] = (result.stopReasonBranchSessions[reason][branch] ?? 0) + 1;
+        }
+        for (const cwd of cwdsInSession) {
+          if (!result.stopReasonProjectSessions[reason]) result.stopReasonProjectSessions[reason] = {};
+          result.stopReasonProjectSessions[reason][cwd] = (result.stopReasonProjectSessions[reason][cwd] ?? 0) + 1;
+        }
+      }
+    }
+  }
+  return result;
+}
+async function parseProjects() {
+  let dirEntries;
+  try {
+    dirEntries = import_fs.default.readdirSync(PROJECTS_DIR, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  const home = import_os.default.homedir();
+  const projectMap = /* @__PURE__ */ new Map();
+  const addProject = (projectPath, sessions, messages) => {
+    const displayName = projectPath.startsWith(home + "/") ? projectPath.slice(home.length + 1) : projectPath;
+    const existing = projectMap.get(projectPath);
+    if (existing) {
+      existing.sessions += sessions;
+      existing.messages += messages;
+    } else {
+      projectMap.set(projectPath, { name: displayName, path: projectPath, sessions, messages, costEstimate: 0 });
+    }
+  };
+  await Promise.all(
+    dirEntries.filter((e) => e.isDirectory()).map(async (dir) => {
+      const dirPath = import_path.default.join(PROJECTS_DIR, dir.name);
+      const indexPath = import_path.default.join(dirPath, "sessions-index.json");
+      try {
+        const index = JSON.parse(import_fs.default.readFileSync(indexPath, "utf8"));
+        for (const entry of index.entries ?? []) {
+          if (entry.projectPath) {
+            addProject(entry.projectPath, 1, entry.messageCount ?? 0);
+          }
+        }
+        return;
+      } catch {
+      }
+      let files;
+      try {
+        files = import_fs.default.readdirSync(dirPath).filter((f) => f.endsWith(".jsonl"));
+      } catch {
+        return;
+      }
+      if (files.length === 0) return;
+      let projectPath = null;
+      for (const file of files.slice(0, 3)) {
+        projectPath = await getCwdFromJsonl(import_path.default.join(dirPath, file));
+        if (projectPath) break;
+      }
+      if (!projectPath) {
+        projectPath = "/" + dir.name.replace(/^-/, "").replace(/-/g, "/");
+      }
+      addProject(projectPath, files.length, 0);
+    })
+  );
+  return Array.from(projectMap.values()).filter((p) => p.sessions > 0).sort((a, b) => b.sessions - a.sessions).slice(0, 15);
+}
+async function parse() {
+  const stats = readStatsCache();
+  const [projects, jsonl] = await Promise.all([parseProjects(), Promise.resolve(parseJSONLFiles())]);
+  const jsonlTotal = Object.values(jsonl.hourlyMessages).reduce((s, n) => s + n, 0);
+  const statsCacheTotal = (stats.dailyActivity ?? []).reduce((s, d) => s + (d.messageCount ?? 0), 0);
+  const scale = statsCacheTotal > 0 ? jsonlTotal / statsCacheTotal : 1;
+  const dailyActivityMap = new Map((stats.dailyActivity ?? []).map((d) => [d.date, { messages: d.messageCount, sessions: d.sessionCount }]));
+  const estimatedModelMessages = {};
+  const estimatedModelSessions = {};
+  for (const dayTokens of stats.dailyModelTokens ?? []) {
+    const day = dailyActivityMap.get(dayTokens.date);
+    const dayMessages = (day?.messages ?? 0) * scale;
+    const daySessions = day?.sessions ?? 0;
+    if (dayMessages === 0 && daySessions === 0) continue;
+    const totalDayTokens = Object.values(dayTokens.tokensByModel).reduce((a, b) => a + b, 0);
+    if (totalDayTokens === 0) continue;
+    for (const [model, tokens] of Object.entries(dayTokens.tokensByModel)) {
+      const frac = tokens / totalDayTokens;
+      estimatedModelMessages[model] = (estimatedModelMessages[model] ?? 0) + dayMessages * frac;
+      estimatedModelSessions[model] = (estimatedModelSessions[model] ?? 0) + daySessions * frac;
+    }
+  }
+  const modelUsage = Object.entries(stats.modelUsage ?? {}).map(([id, usage]) => ({
+    id,
+    name: formatModelName(id),
+    inputTokens: usage.inputTokens ?? 0,
+    outputTokens: usage.outputTokens ?? 0,
+    cacheReadTokens: usage.cacheReadInputTokens ?? 0,
+    cacheCreateTokens: usage.cacheCreationInputTokens ?? 0,
+    costUSD: usage.costUSD > 0 ? usage.costUSD : estimateCost(id, usage.inputTokens ?? 0, usage.outputTokens ?? 0, usage.cacheReadInputTokens ?? 0, usage.cacheCreationInputTokens ?? 0),
+    messages: Math.round(estimatedModelMessages[id] ?? 0),
+    sessions: Math.round(estimatedModelSessions[id] ?? 0),
+    toolCalls: jsonl.modelToolCalls[id] ?? 0,
+    thinkingTurns: jsonl.modelThinkingTurns[id] ?? 0
+  })).sort((a, b) => b.inputTokens + b.outputTokens - (a.inputTokens + a.outputTokens));
+  const rawHours = stats.hourCounts ?? {};
+  const hourCounts = Array.from({ length: 24 }, (_, i) => rawHours[String(i)] ?? 0);
+  const totalToolCalls = (stats.dailyActivity ?? []).reduce(
+    (sum, d) => sum + (d.toolCallCount ?? 0),
+    0
+  );
+  const totalTokens = modelUsage.reduce(
+    (sum, m) => sum + m.inputTokens + m.outputTokens + m.cacheReadTokens + m.cacheCreateTokens,
+    0
+  );
+  const allMinutes = /* @__PURE__ */ new Set([
+    ...Object.keys(jsonl.minutelyMessages),
+    ...Object.values(jsonl.minutelyModelTokens).flatMap((m) => Object.keys(m))
+  ]);
+  const minutelyActivity = Array.from(allMinutes).sort().map((minute) => ({
+    minute,
+    messageCount: jsonl.minutelyMessages[minute] ?? 0,
+    tokensByModel: Object.fromEntries(
+      Object.entries(jsonl.minutelyModelTokens).map(([model, mins]) => [model, mins[minute] ?? 0]).filter(([, v]) => v > 0)
+    )
+  }));
+  const allHours = /* @__PURE__ */ new Set([
+    ...Object.keys(jsonl.hourlyMessages),
+    ...Object.values(jsonl.hourlyModelTokens).flatMap((m) => Object.keys(m))
+  ]);
+  const hourlyActivity = Array.from(allHours).sort().map((hour) => ({
+    hour,
+    messageCount: jsonl.hourlyMessages[hour] ?? 0,
+    sessionCount: jsonl.hourlySessionCounts[hour] ?? 0,
+    tokensByModel: Object.fromEntries(
+      Object.entries(jsonl.hourlyModelTokens).map(([model, hours]) => [model, hours[hour] ?? 0]).filter(([, v]) => v > 0)
+    )
+  }));
+  const topBranches = Object.entries(jsonl.branchCounts).map(([branch, count]) => ({ branch, count })).sort((a, b) => b.count - a.count).slice(0, 10);
+  return {
+    totalSessions: stats.totalSessions ?? 0,
+    totalMessages: stats.totalMessages ?? 0,
+    totalToolCalls,
+    totalTokens,
+    firstSessionDate: stats.firstSessionDate ?? null,
+    longestSession: stats.longestSession ?? null,
+    dailyActivity: stats.dailyActivity ?? [],
+    dailyModelTokens: stats.dailyModelTokens ?? [],
+    modelUsage,
+    hourCounts,
+    hourlyActivity,
+    minutelyActivity,
+    projects,
+    stopReasons: jsonl.stopReasons,
+    stopReasonHourlyCounts: jsonl.stopReasonHourlyCounts,
+    stopReasonDailyCounts: jsonl.stopReasonDailyCounts,
+    stopReasonMiniutelyCounts: jsonl.stopReasonMiniutelyCounts,
+    entrypoints: jsonl.entrypoints,
+    entrypointHourlyCounts: jsonl.entrypointHourlyCounts,
+    entrypointDailyCounts: jsonl.entrypointDailyCounts,
+    entrypointMiniutelyCounts: jsonl.entrypointMiniutelyCounts,
+    topBranches,
+    branchCounts: jsonl.branchCounts,
+    branchHourlyCounts: jsonl.branchHourlyCounts,
+    branchDailyCounts: jsonl.branchDailyCounts,
+    branchMiniutelyCounts: jsonl.branchMiniutelyCounts,
+    branchSessionCounts: jsonl.branchSessionCounts,
+    toolCounts: jsonl.toolCounts,
+    modelToolNames: jsonl.modelToolNames,
+    toolHourlyCounts: jsonl.toolHourlyCounts,
+    toolDailyCounts: jsonl.toolDailyCounts,
+    toolMiniutelyCounts: jsonl.toolMiniutelyCounts,
+    projectDailyMessages: jsonl.projectDailyMessages,
+    projectHourlyMessages: jsonl.projectHourlyMessages,
+    modelStopReasons: jsonl.modelStopReasons,
+    modelBranchSessions: jsonl.modelBranchSessions,
+    modelProjectSessions: jsonl.modelProjectSessions,
+    toolStopReasons: jsonl.toolStopReasons,
+    toolBranchSessions: jsonl.toolBranchSessions,
+    toolProjectSessions: jsonl.toolProjectSessions,
+    toolSessionCounts: jsonl.toolSessionCounts,
+    stopReasonBranchSessions: jsonl.stopReasonBranchSessions,
+    stopReasonProjectSessions: jsonl.stopReasonProjectSessions,
+    stopReasonSessionCounts: jsonl.stopReasonSessionCounts,
+    branchProjectSessions: jsonl.branchProjectSessions
+  };
+}
+
+// src/cli/index.ts
+var PORT = Number(process.env.PORT) || 3131;
+var DASHBOARD_DIR = import_path2.default.join(__dirname, "../dashboard");
+var MIME = {
+  ".html": "text/html; charset=utf-8",
+  ".js": "text/javascript",
+  ".css": "text/css",
+  ".svg": "image/svg+xml",
+  ".ico": "image/x-icon",
+  ".woff2": "font/woff2"
+};
+function serveStatic(res, filePath) {
+  try {
+    const data = import_fs2.default.readFileSync(filePath);
+    const ext = import_path2.default.extname(filePath);
+    res.writeHead(200, { "Content-Type": MIME[ext] ?? "application/octet-stream" });
+    res.end(data);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function openBrowser(url) {
+  const cmd = process.platform === "darwin" ? `open "${url}"` : process.platform === "win32" ? `start "" "${url}"` : `xdg-open "${url}"`;
+  (0, import_child_process.exec)(cmd, (err) => {
+    if (err) console.log("Visit:", url);
+  });
+}
+async function main() {
+  process.stdout.write("Parsing Claude usage data...");
+  let data;
+  try {
+    data = await parse();
+  } catch (err) {
+    console.error("\nError:", err.message);
+    process.exit(1);
+  }
+  const dataJson = JSON.stringify(data);
+  process.stdout.write(" done.\n");
+  const server = import_http.default.createServer((req, res) => {
+    const url = req.url ?? "/";
+    if (url === "/api/data") {
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(dataJson);
+      return;
+    }
+    const urlPath = url === "/" ? "/index.html" : url.split("?")[0];
+    const filePath = import_path2.default.join(DASHBOARD_DIR, urlPath);
+    if (serveStatic(res, filePath)) return;
+    const indexPath = import_path2.default.join(DASHBOARD_DIR, "index.html");
+    if (!serveStatic(res, indexPath)) {
+      res.writeHead(404);
+      res.end("Not found");
+    }
+  });
+  server.listen(PORT, "127.0.0.1", () => {
+    const url = `http://localhost:${PORT}`;
+    console.log(`Dashboard running at ${url}`);
+    openBrowser(url);
+    console.log("Press Ctrl+C to stop.");
+  });
+  server.on("error", (err) => {
+    if (err.code === "EADDRINUSE") {
+      console.error(`Port ${PORT} is in use. Set PORT env var to use a different one.`);
+    } else {
+      console.error("Server error:", err.message);
+    }
+    process.exit(1);
+  });
+}
+main();