tokely 0.5.1 → 0.5.3

package/README.md

@@ -24,22 +24,25 @@ tokely
 ## Usage
 
 ```bash
-tokely [--all] [--claude] [--codex] [--cursor] [--gemini] [--opencode] [--pi] [--dark] [--format png|svg|json] [--output ./heatmap-last-year.png]
+tokely [--all] [--today] [--claude] [--codex] [--cursor] [--gemini] [--opencode] [--openclaw] [--pi] [--dark] [--format png|svg|json] [--output ./heatmap-last-year.png]
 ```
 
 By default, the CLI:
 
 - scans all supported providers
+- renders the top 5 providers with available data (priority: Claude Code → Codex → Cursor → Open Code → OpenClaw)
 - writes `./heatmap-last-year.png`
 - infers the date window as the rolling last year ending today
 
 ## Options
 
+- `--today`: show today's usage stats in terminal
 - `--claude`: include only Claude Code data
 - `--codex`: include only Codex data
 - `--cursor`: include only Cursor data
 - `--gemini`: include only Gemini CLI data
 - `--opencode`: include only Open Code data
+- `--openclaw`: include only OpenClaw data
 - `--pi`: include only Pi Coding Agent data
 - `--all`: merge all providers into one combined graph
 - `--dark`: render the image with the dark theme
@@ -121,6 +124,7 @@ npx tokely --dark --format svg --output ./out/heatmap-dark.svg
 - Cursor: reads `cursorAuth/accessToken` and `cursorAuth/refreshToken` from `$CURSOR_STATE_DB_PATH`, `$CURSOR_CONFIG_DIR/User/globalStorage/state.vscdb`, `~/Library/Application Support/Cursor/User/globalStorage/state.vscdb` (macOS), `%APPDATA%/Cursor/User/globalStorage/state.vscdb` (Windows), or `~/.config/Cursor/User/globalStorage/state.vscdb` (Linux), then loads usage from Cursor's CSV export endpoint
 - Gemini CLI: `$GEMINI_CONFIG_DIR/tmp/**/chats/session-*.json` or `~/.gemini/tmp/**/chats/session-*.json`
 - Open Code: prefers `$OPENCODE_DATA_DIR/opencode.db` or `~/.local/share/opencode/opencode.db`, and falls back to `$OPENCODE_DATA_DIR/storage/message` or `~/.local/share/opencode/storage/message`
+- OpenClaw: `$HOME/.openclaw/agents`, `$HOME/.clawdbot/agents`, `$HOME/.moltbot/agents`, or `$HOME/.moldbot/agents` (reads `*.jsonl` session transcripts)
 - Pi Coding Agent: `$PI_CODING_AGENT_DIR/sessions` or `~/.pi/agent/sessions`
 
 When Claude Code falls back to `stats-cache.json`, the daily input/output/cache split is reconstructed from Claude's cached model totals because the older layout does not keep per-request usage logs.
@@ -128,8 +132,9 @@ When Claude Code falls back to `history.jsonl`, those days are rendered as activ
 
 ## Exit behavior
 
-- If no provider flags are passed, `tokely` renders every provider with available data.
-- If `--all` is passed, `tokely` loads all providers and renders one combined graph with merged totals, streaks, and model rankings.
+- By default, renders the top 4 providers with available data.
+- Priority order: Claude Code → Codex → Cursor → Open Code → Amp → Gemini CLI → Pi Coding Agent.
+- Use `--all` to merge all providers, or specify providers explicitly.
 - Pi Coding Agent usage is derived from assistant messages in Pi session logs, grouped by the model that handled each turn.
 - If provider flags are passed and a requested provider has no data, the command exits with an error.
 - If no provider has data, the command exits with an error.

package/dist/cli.js

@@ -5833,6 +5833,35 @@ var heatmapThemes = {
       ]
     }
   },
+  openclaw: {
+    title: "OpenClaw",
+    colors: {
+      light: [
+        "#fef2f2",
+        // red-50
+        "#fecaca",
+        // red-200
+        "#fca5a5",
+        // red-300
+        "#ef4444",
+        // red-500
+        "#991b1b"
+        // red-800
+      ],
+      dark: [
+        "#450a0a",
+        // red-950
+        "#991b1b",
+        // red-800
+        "#dc2626",
+        // red-600
+        "#fca5a5",
+        // red-300
+        "#fecaca"
+        // red-200
+      ]
+    }
+  },
   pi: {
     title: "Pi Coding Agent",
     colors: {
@@ -5863,7 +5892,7 @@ var heatmapThemes = {
     }
   },
   all: {
-    title: "Amp / Claude Code / Codex / Cursor / Gemini CLI / Open Code / Pi Coding Agent",
+    title: "Amp / Claude Code / Codex / Cursor / Gemini CLI / Open Code / OpenClaw / Pi Coding Agent",
     titleCaption: "Total usage from",
     colors: {
       light: [
@@ -7874,6 +7903,7 @@ var providerIds = [
   "codex",
   "cursor",
   "opencode",
+  "openclaw",
   "amp",
   "gemini",
   "pi"
@@ -7882,7 +7912,8 @@ var defaultProviderIds = [
   "claude",
   "codex",
   "cursor",
-  "opencode"
+  "opencode",
+  "openclaw"
 ];
 var providerStatusLabel = {
   amp: "Amp",
@@ -7891,6 +7922,7 @@ var providerStatusLabel = {
   cursor: "Cursor",
   gemini: "Gemini CLI",
   opencode: "Open Code",
+  openclaw: "OpenClaw",
   pi: "Pi Coding Agent"
 };
 
@@ -8088,21 +8120,149 @@ async function loadOpenCodeRows(start, end) {
   );
 }
 
-// src/lib/pi.ts
-import { existsSync as existsSync7 } from "fs";
+// src/lib/openclaw.ts
+import { existsSync as existsSync7, readFileSync, statSync } from "fs";
+import { readdirSync as readdirSync2 } from "fs";
+import { join as join8 } from "path";
 import { homedir as homedir7 } from "os";
-import { join as join8, resolve as resolve7 } from "path";
+function scanOpenClawJsonlFiles() {
+  const dirs = [
+    join8(homedir7(), ".openclaw", "agents"),
+    join8(homedir7(), ".clawdbot", "agents"),
+    join8(homedir7(), ".moltbot", "agents"),
+    join8(homedir7(), ".moldbot", "agents")
+  ];
+  const files = [];
+  for (const dir of dirs) {
+    if (!existsSync7(dir)) continue;
+    scanDirRecursive(dir, files);
+  }
+  return files;
+}
+function scanDirRecursive(dir, files) {
+  try {
+    const entries = readdirSync2(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = join8(dir, entry.name);
+      if (entry.isDirectory()) {
+        scanDirRecursive(fullPath, files);
+      } else if (entry.name.endsWith(".jsonl")) {
+        files.push(fullPath);
+      }
+    }
+  } catch {
+  }
+}
+function parseTranscript(filePath, start, end, totals, modelTotals, recentModelTotals) {
+  const content = readFileSync(filePath, "utf-8");
+  const lines = content.split("\n").filter((l) => l.trim());
+  let currentModel = null;
+  let currentProvider = null;
+  const fileMtime = statSync(filePath).mtimeMs;
+  const recentStart = getRecentWindowStart(end);
+  for (const line of lines) {
+    let entry;
+    try {
+      entry = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    const type = entry.type;
+    if (type === "model_change") {
+      currentModel = entry.modelId ?? currentModel;
+      currentProvider = entry.provider ?? currentProvider;
+      continue;
+    }
+    if (type === "custom" && entry.customType === "model-snapshot") {
+      const data = entry.data;
+      if (data) {
+        currentModel = data.modelId ?? currentModel;
+        currentProvider = data.provider ?? currentProvider;
+      }
+      continue;
+    }
+    if (type === "message") {
+      const msg = entry.message;
+      if (!msg || msg.role !== "assistant") continue;
+      const model = msg.model ?? currentModel;
+      if (!model) continue;
+      const usage = msg.usage;
+      if (!usage) continue;
+      const input = Math.max(usage.input ?? 0, 0);
+      const output = Math.max(usage.output ?? 0, 0);
+      const cacheRead = Math.max(usage.cacheRead ?? 0, 0);
+      const cacheWrite = Math.max(usage.cacheWrite ?? 0, 0);
+      const total = Math.max(usage.totalTokens ?? 0, 0);
+      if (total <= 0 && input <= 0 && output <= 0) continue;
+      const ts = msg.timestamp ?? fileMtime;
+      const timestamp = new Date(ts);
+      if (timestamp < start || timestamp > end) continue;
+      const normalizedModel = normalizeModelName(model);
+      addDailyTokenTotals(
+        totals,
+        timestamp,
+        {
+          input,
+          output,
+          cache: { input: cacheRead, output: cacheWrite },
+          total
+        },
+        normalizedModel
+      );
+      addModelTokenTotals(modelTotals, normalizedModel, {
+        input,
+        output,
+        cache: { input: cacheRead, output: cacheWrite },
+        total
+      });
+      if (timestamp >= recentStart) {
+        addModelTokenTotals(recentModelTotals, normalizedModel, {
+          input,
+          output,
+          cache: { input: cacheRead, output: cacheWrite },
+          total
+        });
+      }
+    }
+  }
+}
+function isOpenClawAvailable() {
+  return scanOpenClawJsonlFiles().length > 0;
+}
+async function loadOpenClawRows(start, end) {
+  const files = scanOpenClawJsonlFiles();
+  const totals = /* @__PURE__ */ new Map();
+  const modelTotals = /* @__PURE__ */ new Map();
+  const recentModelTotals = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    try {
+      parseTranscript(file, start, end, totals, modelTotals, recentModelTotals);
+    } catch {
+    }
+  }
+  const daily = totalsToRows(totals);
+  return {
+    provider: "openclaw",
+    daily,
+    insights: getProviderInsights(modelTotals, recentModelTotals, daily, end)
+  };
+}
+
+// src/lib/pi.ts
+import { existsSync as existsSync8 } from "fs";
+import { homedir as homedir8 } from "os";
+import { join as join9, resolve as resolve7 } from "path";
 var PI_AGENT_DIR_ENV = "PI_CODING_AGENT_DIR";
 var CLASSIFICATION_PREFIX_BYTES2 = 16 * 1024;
 function getPiAgentDir() {
   const configuredAgentDir = process.env[PI_AGENT_DIR_ENV]?.trim();
-  return configuredAgentDir ? resolve7(configuredAgentDir) : join8(homedir7(), ".pi", "agent");
+  return configuredAgentDir ? resolve7(configuredAgentDir) : join9(homedir8(), ".pi", "agent");
 }
 async function getPiSessionFiles() {
-  return listFilesRecursive(join8(getPiAgentDir(), "sessions"), ".jsonl");
+  return listFilesRecursive(join9(getPiAgentDir(), "sessions"), ".jsonl");
 }
 function isPiAvailable() {
-  return existsSync7(join8(getPiAgentDir(), "sessions"));
+  return existsSync8(join9(getPiAgentDir(), "sessions"));
 }
 function classifyPiRecord(prefix) {
   if (prefix.includes('"type":"message"') && prefix.includes('"role":"assistant"')) {
@@ -8208,6 +8368,7 @@ function createEmptyProviderAvailability() {
     cursor: false,
     gemini: false,
     opencode: false,
+    openclaw: false,
     pi: false
   };
 }
@@ -8225,6 +8386,8 @@ async function isProviderAvailable(provider) {
       return isGeminiAvailable();
     case "opencode":
       return isOpenCodeAvailable();
+    case "openclaw":
+      return isOpenClawAvailable();
     case "pi":
       return isPiAvailable();
     default: {
@@ -8260,6 +8423,7 @@ async function aggregateUsage({
     cursor: null,
     gemini: null,
     opencode: null,
+    openclaw: null,
     pi: null
   };
   const warnings = [];
@@ -8284,6 +8448,9 @@ async function aggregateUsage({
       case "opencode":
         summary = await loadOpenCodeRows(start, end);
         break;
+      case "openclaw":
+        summary = await loadOpenClawRows(start, end);
+        break;
       case "pi":
         summary = await loadPiRows(start, end);
         break;
@@ -8307,16 +8474,18 @@ var HELP_TEXT = `tokely
 Generate rolling 1-year usage heatmap image(s) (today is the latest day).
 
 Usage:
-  tokely [--all] [--amp] [--claude] [--codex] [--cursor] [--gemini] [--opencode] [--pi] [--dark] [--format png|svg|json] [--output ./heatmap-last-year.png]
+  tokely [--all] [--today] [--amp] [--claude] [--codex] [--cursor] [--gemini] [--opencode] [--openclaw] [--pi] [--dark] [--format png|svg|json] [--output ./heatmap-last-year.png]
 
 Options:
   --all                       Render one merged graph for all providers
+  --today                     Show today's usage stats in terminal
   --amp                       Render Amp graph
   --claude                    Render Claude Code graph
   --codex                     Render Codex graph
   --cursor                    Render Cursor graph
   --gemini                    Render Gemini CLI graph
   --opencode                  Render Open Code graph
+  --openclaw                  Render OpenClaw graph
   --pi                        Render Pi Coding Agent graph
   --dark                      Render with the dark theme
   -f, --format                Output format: png, svg, or json (default: png)
@@ -8335,12 +8504,14 @@ function validateArgs(values) {
       help: ow.boolean,
       dark: ow.boolean,
       all: ow.boolean,
+      today: ow.boolean,
       amp: ow.boolean,
       claude: ow.boolean,
       codex: ow.boolean,
       cursor: ow.boolean,
       gemini: ow.boolean,
       opencode: ow.boolean,
+      openclaw: ow.boolean,
       pi: ow.boolean
     })
   );
@@ -8407,7 +8578,7 @@ function getRequestedProviders(values) {
   return providerIds.filter((id) => values[id]);
 }
 function getMergedNoDataMessage() {
-  return "No usage data found for Amp, Claude Code, Codex, Cursor, Gemini CLI, Open Code, or Pi Coding Agent.";
+  return "No usage data found for Claude Code, Codex, Cursor, Open Code, OpenClaw, Amp, Gemini CLI, or Pi Coding Agent.";
 }
 function getRequestedMissingProvidersMessage(missing) {
   return `Requested provider data not found: ${missing.map((provider) => providerStatusLabel[provider]).join(", ")}`;
@@ -8439,7 +8610,7 @@ function getDefaultOutputProviderIds(rowsByProvider) {
       continue;
     }
     selected.push(provider);
-    if (selected.length === 4) {
+    if (selected.length === 5) {
       return selected;
     }
   }
@@ -8487,6 +8658,62 @@ function printRunSummary(outputPath, format, colorMode, startDate, endDate, rend
 `
   );
 }
+function formatTokens(value) {
+  const units = [
+    { size: 1e12, suffix: "T" },
+    { size: 1e9, suffix: "B" },
+    { size: 1e6, suffix: "M" },
+    { size: 1e3, suffix: "K" }
+  ];
+  for (const unit of units) {
+    if (value >= unit.size) {
+      const scaled = value / unit.size;
+      const precision = scaled >= 100 ? 0 : scaled >= 10 ? 1 : 2;
+      const compact = scaled.toFixed(precision).replace(/\.0+$/, "").replace(/(\.\d*[1-9])0+$/, "$1");
+      return `${compact}${unit.suffix}`;
+    }
+  }
+  return new Intl.NumberFormat("en-US").format(value);
+}
+function printTodayStats(rowsByProvider, providers) {
+  const today = formatLocalDate(/* @__PURE__ */ new Date());
+  const rows = [];
+  for (const provider of providers) {
+    const summary = rowsByProvider[provider];
+    if (!summary) {
+      continue;
+    }
+    const todayRow = summary.daily.find(
+      (row) => formatLocalDate(row.date) === today
+    );
+    if (!todayRow || todayRow.total <= 0 && (todayRow.displayValue ?? 0) <= 0) {
+      continue;
+    }
+    const topModel = todayRow.breakdown.length > 0 ? `${todayRow.breakdown[0].name} (${formatTokens(todayRow.breakdown[0].tokens.total)})` : "-";
+    rows.push({
+      provider: providerStatusLabel[provider],
+      input: formatTokens(todayRow.input),
+      output: formatTokens(todayRow.output),
+      total: formatTokens(todayRow.total),
+      topModel
+    });
+  }
+  if (rows.length === 0) {
+    process.stdout.write(`
+No usage data found for today (${today}).
+`);
+    return;
+  }
+  const header = "| Provider | Input | Output | Total | Top Model |\n| --- | --- | --- | --- | --- |";
+  const body = rows.map(
+    (row) => `| ${row.provider} | ${row.input} | ${row.output} | ${row.total} | ${row.topModel} |`
+  ).join("\n");
+  process.stdout.write(`
+${header}
+${body}
+
+`);
+}
 async function main() {
   let spinner;
   const parsed = parseArgs({
@@ -8496,12 +8723,14 @@ async function main() {
       help: { type: "boolean", short: "h", default: false },
       dark: { type: "boolean", default: false },
       all: { type: "boolean", default: false },
+      today: { type: "boolean", default: false },
       amp: { type: "boolean", default: false },
       claude: { type: "boolean", default: false },
       codex: { type: "boolean", default: false },
       cursor: { type: "boolean", default: false },
       gemini: { type: "boolean", default: false },
       opencode: { type: "boolean", default: false },
+      openclaw: { type: "boolean", default: false },
       pi: { type: "boolean", default: false }
     },
     allowPositionals: false
@@ -8533,7 +8762,13 @@ async function main() {
       process.stderr.write(`${warning}
 `);
     }
-    printProviderAvailability(availabilityByProvider, inspectedProviders);
+    if (!values.today) {
+      printProviderAvailability(availabilityByProvider, inspectedProviders);
+    }
+    if (values.today) {
+      printTodayStats(rowsByProvider, inspectedProviders);
+      return;
+    }
     const exportProviders = getOutputProviders(
       values,
       availabilityByProvider,