tokentracker-cli 0.21.2 → 0.22.0

package/src/commands/wrapped.js

@@ -0,0 +1,150 @@
+"use strict";
+
+const os = require("node:os");
+const path = require("node:path");
+const fs = require("node:fs");
+
+const { resolveTrackerPaths } = require("../lib/tracker-paths");
+const { aggregateWrapped, formatCompact } = require("../lib/wrapped-aggregator");
+
+async function readQueueRows(queuePath) {
+  if (!fs.existsSync(queuePath)) return [];
+  const raw = await fs.promises.readFile(queuePath, "utf8");
+  const rows = [];
+  for (const line of raw.split("\n")) {
+    if (!line.trim()) continue;
+    try {
+      rows.push(JSON.parse(line));
+    } catch (_e) {
+      // skip malformed line — production queues sometimes hold a partial
+      // tail row mid-write that becomes valid on the next read.
+    }
+  }
+  return rows;
+}
+
+function parseArgs(argv) {
+  const out = { year: null, json: false };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === "--json") out.json = true;
+    else if (a === "--year") {
+      const v = argv[++i];
+      const y = Number(v);
+      if (!Number.isInteger(y) || y < 2000 || y > 2100) {
+        throw new Error(`--year expects a 4-digit year, got: ${v}`);
+      }
+      out.year = y;
+    } else throw new Error(`Unknown option: ${a}`);
+  }
+  return out;
+}
+
+function renderAscii(wrapped) {
+  const lines = [];
+  const w = 60;
+  const border = "═".repeat(w - 2);
+  const center = (s) => {
+    const text = String(s);
+    const padTotal = Math.max(0, w - 2 - text.length);
+    const left = Math.floor(padTotal / 2);
+    const right = padTotal - left;
+    return `║${" ".repeat(left)}${text}${" ".repeat(right)}║`;
+  };
+  const row = (label, value) => {
+    const text = `  ${label}: ${value}`;
+    const right = Math.max(0, w - 2 - text.length);
+    return `║${text}${" ".repeat(right)}║`;
+  };
+
+  lines.push(`╔${border}╗`);
+  lines.push(center(""));
+  lines.push(center(`TokenTracker Wrapped · ${wrapped.year}`));
+  lines.push(center(""));
+  lines.push(`╠${border}╣`);
+  lines.push(row("Total tokens", formatCompact(wrapped.totals.tokens)));
+  lines.push(row("Conversations", wrapped.totals.conversations.toLocaleString("en-US")));
+  lines.push(row("Active days", `${wrapped.totals.active_days} / 365`));
+  lines.push(row("Tools used", String(wrapped.totals.sources)));
+  lines.push(row("Models used", String(wrapped.totals.models)));
+  if (wrapped.peak_hour) {
+    lines.push(
+      row(
+        "Peak hour",
+        `${String(wrapped.peak_hour.hour).padStart(2, "0")}:00 UTC (${formatCompact(wrapped.peak_hour.tokens)})`,
+      ),
+    );
+  }
+  if (wrapped.longest_streak.days > 0) {
+    lines.push(
+      row("Longest streak", `${wrapped.longest_streak.days} days (${wrapped.longest_streak.from} → ${wrapped.longest_streak.to})`),
+    );
+  }
+  lines.push(`╠${border}╣`);
+
+  if (wrapped.top.sources.length > 0) {
+    lines.push(row("Top tools", ""));
+    for (const s of wrapped.top.sources.slice(0, 3)) {
+      lines.push(row(`  ${s.source}`, `${formatCompact(s.tokens)} (${(s.share * 100).toFixed(0)}%)`));
+    }
+  }
+  if (wrapped.top.models.length > 0) {
+    lines.push(`╠${border}╣`);
+    lines.push(row("Top models", ""));
+    for (const m of wrapped.top.models.slice(0, 3)) {
+      lines.push(row(`  ${m.model}`, `${formatCompact(m.tokens)} (${(m.share * 100).toFixed(0)}%)`));
+    }
+  }
+  if (wrapped.top.days.length > 0) {
+    lines.push(`╠${border}╣`);
+    lines.push(row("Top days", ""));
+    for (const d of wrapped.top.days.slice(0, 3)) {
+      lines.push(row(`  ${d.day}`, formatCompact(d.tokens)));
+    }
+  }
+  if (wrapped.highlights.length > 0) {
+    lines.push(`╠${border}╣`);
+    const max = w - 4; // 2 borders + 2 padding
+    for (const h of wrapped.highlights) {
+      // Wrap long highlights into multiple rows.
+      for (let start = 0; start < h.length; start += max) {
+        const segment = h.slice(start, start + max);
+        const padded = ` ${segment}`;
+        const right = Math.max(0, w - 2 - padded.length);
+        lines.push(`║${padded}${" ".repeat(right)}║`);
+      }
+    }
+  }
+  lines.push(`╚${border}╝`);
+  return lines.join("\n");
+}
+
+async function cmdWrapped(argv = []) {
+  const opts = parseArgs(argv);
+  const home = os.homedir();
+  const { trackerDir } = await resolveTrackerPaths({ home });
+  const queuePath = path.join(trackerDir, "queue.jsonl");
+
+  const rows = await readQueueRows(queuePath);
+  if (rows.length === 0) {
+    if (opts.json) {
+      process.stdout.write(JSON.stringify({ error: "no data" }, null, 2) + "\n");
+    } else {
+      process.stdout.write(
+        "No queue data found yet. Run `tracker sync` first to ingest some history.\n",
+      );
+    }
+    return;
+  }
+
+  const wrapped = aggregateWrapped(rows, opts.year ? { year: opts.year } : {});
+
+  if (opts.json) {
+    process.stdout.write(JSON.stringify(wrapped, null, 2) + "\n");
+    return;
+  }
+
+  process.stdout.write(renderAscii(wrapped) + "\n");
+}
+
+module.exports = { cmdWrapped };

package/src/lib/local-api.js

@@ -175,6 +175,12 @@ function aggregateByDay(rows, timeZoneContext = null) {
     a.cache_creation_input_tokens += row.cache_creation_input_tokens || 0;
     a.reasoning_output_tokens += row.reasoning_output_tokens || 0;
     a.conversation_count += row.conversation_count || 0;
+
+    if (!a.models) {
+      a.models = {};
+    }
+    const model = row.model || "unknown";
+    a.models[model] = (a.models[model] || 0) + (row.total_tokens || 0);
   }
   return Array.from(byDay.values()).sort((a, b) => a.day.localeCompare(b.day));
 }
@@ -999,6 +1005,17 @@ function createLocalApiHandler({ queuePath }) {
       return true;
     }
 
+    // --- wrapped (year-end summary, à la Spotify Wrapped) ---
+    if (p === "/functions/tokentracker-wrapped") {
+      const yearParam = url.searchParams.get("year");
+      const year = yearParam ? Number(yearParam) : null;
+      const { rows, scope, excludedSources } = scopedQueueRows(qp, url);
+      const { aggregateWrapped } = require("./wrapped-aggregator");
+      const summary = aggregateWrapped(rows, year ? { year } : {});
+      json(res, { scope, excluded_sources: excludedSources, ...summary });
+      return true;
+    }
+
     // --- usage-summary ---
     if (p === "/functions/tokentracker-usage-summary") {
       const from = url.searchParams.get("from") || "";
@@ -1111,14 +1128,32 @@ function createLocalApiHandler({ queuePath }) {
         const day = cursor.toISOString().slice(0, 10);
         const data = byDay.get(day);
         const billable = data?.billable_total_tokens || 0;
-        cells.push({ day, total_tokens: data?.total_tokens || 0, billable_total_tokens: billable, level: calcLevel(billable) });
+        cells.push({ day, total_tokens: data?.total_tokens || 0, billable_total_tokens: billable, level: calcLevel(billable), models: data?.models || null });
         cursor.setUTCDate(cursor.getUTCDate() + 1);
       }
       const weeksArr = [];
       for (let i = 0; i < cells.length; i += 7) {
         weeksArr.push(cells.slice(i, i + 7));
       }
-      json(res, { from, to, scope, excluded_sources: excludedSources, week_starts_on: "sun", active_days: cells.filter((c) => c.billable_total_tokens > 0).length, streak_days: 0, weeks: weeksArr });
+
+      let totalCostUsd = 0;
+      for (const d of daily) {
+        if (d.day >= from && d.day <= to) {
+          totalCostUsd += d.total_cost_usd || 0;
+        }
+      }
+
+      json(res, { 
+        from, 
+        to, 
+        scope, 
+        excluded_sources: excludedSources, 
+        week_starts_on: "sun", 
+        active_days: cells.filter((c) => c.billable_total_tokens > 0).length, 
+        streak_days: 0, 
+        weeks: weeksArr,
+        total_cost_usd: totalCostUsd
+      });
       return true;
     }
 

package/src/lib/passive-mode.js

@@ -0,0 +1,185 @@
+/**
+ * Passive-mode detection.
+ *
+ * Token Tracker normally collects token usage by installing SessionEnd hooks
+ * into supported CLIs (Claude Code, Codex CLI, Gemini CLI, …). The hook
+ * fires `notify.cjs` after each turn → sync runs immediately → data is
+ * fresh within seconds.
+ *
+ * On environments where hook installation fails — WSL with read-only mount,
+ * UNC paths on Windows, locked `settings.json`, sandboxed processes —
+ * SessionEnd hooks never fire, but the underlying CLIs *still* write
+ * session logs (`~/.claude/projects/`, `~/.gemini/sessions/`, etc.). Our
+ * parsers can read those logs directly without the hook; the only loss is
+ * "data is fresh within seconds" → it's now "data is fresh after the next
+ * scheduled `tracker sync`".
+ *
+ * This module surfaces that fact: for each hook-driven provider, decide
+ * whether the local install is in **passive mode** (no hook + log dir
+ * present). `tracker status` reports it, and the dashboard can show a
+ * single banner asking the user whether to acknowledge & continue in
+ * passive mode or attempt re-install (`tracker init`).
+ *
+ * Detection is purely best-effort — we never *fail* sync because hooks are
+ * missing; we just label the source so users / AI agents know latency is
+ * minutes, not seconds.
+ */
+"use strict";
+
+const fs = require("node:fs");
+const path = require("node:path");
+
+/**
+ * @typedef {Object} PassiveProvider
+ * @property {string} name              - canonical provider name
+ * @property {boolean} hook_expected    - whether this provider supports hooks
+ * @property {boolean} hook_installed   - true when the hook is set
+ * @property {boolean} logs_present     - true when the provider's log dir
+ *                                        exists and contains at least one
+ *                                        session file we can parse
+ * @property {boolean} passive          - true iff hook_expected &&
+ *                                        !hook_installed && logs_present
+ * @property {string|null} hook_failure_reason - if hook_expected and not
+ *                                        installed, why we think it failed
+ *                                        (e.g. "settings.json not writable",
+ *                                        "config dir not found")
+ */
+
+function dirHasFile(dir, predicate) {
+  if (!dir || !fs.existsSync(dir)) return false;
+  let entries;
+  try {
+    entries = fs.readdirSync(dir, { withFileTypes: true });
+  } catch (_e) {
+    return false;
+  }
+  for (const entry of entries) {
+    const full = path.join(dir, entry.name);
+    // Let the predicate accept either a file OR a directory name (so
+    // "sessions" or "tmp" as a bare subdirectory still counts).
+    if (!predicate || predicate(full, entry.name, entry.isDirectory())) return true;
+    if (entry.isDirectory()) {
+      // Shallow recurse — at most 1 level (covers projects/<name>/*.jsonl)
+      if (dirHasFile(full, predicate)) return true;
+    }
+  }
+  return false;
+}
+
+function classifyWritableFailure(filePath) {
+  if (!filePath) return "no path";
+  try {
+    fs.accessSync(filePath, fs.constants.W_OK);
+    return "writable (hook may have been removed externally)";
+  } catch (e) {
+    if (e && e.code === "ENOENT") return "settings file missing";
+    if (e && e.code === "EACCES") return "permission denied";
+    if (e && e.code === "EROFS") return "read-only filesystem";
+    return e?.code || "unknown";
+  }
+}
+
+/**
+ * Detect passive mode for each hook-driven provider.
+ *
+ * @param {Object} opts
+ * @param {string} opts.home  - user home directory
+ * @param {Object} opts.hookStatus - per-provider hook-installed booleans
+ *   (already collected by status.js); shape: { claude, gemini, codex,
+ *   every_code, opencode, openclaw, codebuddy, grok }
+ * @returns {PassiveProvider[]}
+ */
+function detectPassiveProviders({ home, hookStatus }) {
+  const out = [];
+
+  // Claude Code — logs at ~/.claude/projects/<name>/*.jsonl
+  out.push(buildEntry({
+    name: "claude",
+    hookExpected: true,
+    hookInstalled: Boolean(hookStatus?.claude),
+    logsDir: path.join(home, ".claude", "projects"),
+    logsPredicate: (full) => full.endsWith(".jsonl"),
+    settingsPath: path.join(home, ".claude", "settings.json"),
+  }));
+
+  // Gemini CLI — logs at ~/.gemini/tmp/<session-id>/logs.json
+  // (path varies by version; presence of ~/.gemini/sessions or
+  // ~/.gemini/tmp is enough to call it "active")
+  out.push(buildEntry({
+    name: "gemini",
+    hookExpected: true,
+    hookInstalled: Boolean(hookStatus?.gemini),
+    logsDir: path.join(home, ".gemini"),
+    logsPredicate: (_full, name, isDir) =>
+      (isDir && (name === "tmp" || name === "sessions")) || name === "logs.json",
+    settingsPath: path.join(home, ".gemini", "settings.json"),
+  }));
+
+  // Codex CLI — logs at ~/.codex/sessions/
+  // Match either a "sessions" subdir (even if empty — the CLI created it)
+  // or any *.jsonl session file.
+  out.push(buildEntry({
+    name: "codex",
+    hookExpected: true,
+    hookInstalled: Boolean(hookStatus?.codex_notify ?? hookStatus?.codex),
+    logsDir: path.join(home, ".codex"),
+    logsPredicate: (_full, name, isDir) =>
+      (isDir && name === "sessions") || (!isDir && name.endsWith(".jsonl")),
+    settingsPath: path.join(home, ".codex", "config.toml"),
+  }));
+
+  // Every Code — same shape as Codex, different home
+  out.push(buildEntry({
+    name: "every_code",
+    hookExpected: true,
+    hookInstalled: Boolean(hookStatus?.every_code_notify ?? hookStatus?.every_code),
+    logsDir: path.join(home, ".code"),
+    logsPredicate: (_full, name, isDir) =>
+      (isDir && name === "sessions") || (!isDir && name.endsWith(".jsonl")),
+    settingsPath: path.join(home, ".code", "config.toml"),
+  }));
+
+  // CodeBuddy — Claude-fork; hook in ~/.codebuddy/settings.json
+  out.push(buildEntry({
+    name: "codebuddy",
+    hookExpected: true,
+    hookInstalled: Boolean(hookStatus?.codebuddy),
+    logsDir: path.join(home, ".codebuddy"),
+    logsPredicate: (_full, name) => name === "projects" || name.endsWith(".jsonl"),
+    settingsPath: path.join(home, ".codebuddy", "settings.json"),
+  }));
+
+  return out;
+}
+
+function buildEntry({ name, hookExpected, hookInstalled, logsDir, logsPredicate, settingsPath }) {
+  const logsPresent = dirHasFile(logsDir, logsPredicate);
+  const passive = hookExpected && !hookInstalled && logsPresent;
+  let reason = null;
+  if (hookExpected && !hookInstalled) {
+    reason = classifyWritableFailure(settingsPath);
+  }
+  return {
+    name,
+    hook_expected: hookExpected,
+    hook_installed: hookInstalled,
+    logs_present: logsPresent,
+    passive,
+    hook_failure_reason: reason,
+  };
+}
+
+/**
+ * Convenience boolean: is at least one provider in passive mode?
+ */
+function isPassiveModeActive(providers) {
+  return providers.some((p) => p.passive);
+}
+
+module.exports = {
+  detectPassiveProviders,
+  isPassiveModeActive,
+  // Exposed for unit testing
+  dirHasFile,
+  classifyWritableFailure,
+};