npm - tokentracker-cli - Versions diffs - 0.81.3 → 0.82.1 - Mend

tokentracker-cli 0.81.3 → 0.82.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (86) hide show

package/dashboard/dist/index.html CHANGED Viewed

@@ -249,8 +249,8 @@
         ]
       }
     </script>
-    <script type="module" crossorigin src="/assets/__vite-browser-external-CxN2E6q5.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/__vite-browser-external-CQxW1DuO.css">
+    <script type="module" crossorigin src="/assets/__vite-browser-external-CHbEWSwX.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/__vite-browser-external-Cd947_ni.css">
   </head>
   <body>
     <main class="aeo-seed-content" aria-label="Token Tracker AI-readable summary">

package/dashboard/dist/share.html CHANGED Viewed

@@ -75,8 +75,8 @@
         "description": "Shareable Token Tracker dashboard snapshot."
       }
     </script>
-    <script type="module" crossorigin src="/assets/__vite-browser-external-CxN2E6q5.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/__vite-browser-external-CQxW1DuO.css">
+    <script type="module" crossorigin src="/assets/__vite-browser-external-CHbEWSwX.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/__vite-browser-external-Cd947_ni.css">
   </head>
   <body>
     <main class="aeo-seed-content" aria-label="Token Tracker share page summary">

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "tokentracker-cli",
-  "version": "0.81.3",
+  "version": "0.82.1",
   "description": "Local-first AI coding token usage and cost tracker for 27 tools, with a dashboard, desktop pet, widgets, achievements, and native macOS/Windows apps.",
   "main": "src/cli.js",
   "bin": {

package/src/cli.js CHANGED Viewed

@@ -7,6 +7,7 @@ const { cmdUninstall } = require("./commands/uninstall");
 const { cmdServe } = require("./commands/serve");
 const { cmdDeviceLogin } = require("./commands/device-login");
 const { cmdWrapped } = require("./commands/wrapped");
+const { cmdSessions } = require("./commands/sessions");
 async function run(argv) {
   const [command, ...rest] = argv;
@@ -56,6 +57,9 @@ async function run(argv) {
     case "wrapped":
       await cmdWrapped(rest);
       return;
+    case "sessions":
+      await cmdSessions(rest);
+      return;
     default:
       throw new Error(`Unknown command: ${command}`);
   }
@@ -79,6 +83,7 @@ function printHelp() {
       "  npx tokentracker [--debug] uninstall [--purge]",
       "  npx tokentracker [--debug] device-login [--json] [--base-url <url>]",
       "  npx tokentracker [--debug] wrapped [--year 2026] [--json]",
+      "  npx tokentracker sessions [--from YYYY-MM-DD] [--to YYYY-MM-DD] [--format json|csv] [--out file] [--refresh] [--no-git]",
       "",
       "Notes:",
       "  - init: consent first, local setup next, browser sign-in last.",
@@ -93,6 +98,7 @@ function printHelp() {
       "  - --from-openclaw marks sync runs triggered by the OpenClaw session plugin.",
       "  - --debug shows original backend errors.",
       "  - device-login pairs a headless CLI / SSH session with a browser sign-in (15-min code).",
+      "  - sessions exports metadata-only Claude/Codex efficiency analytics; no prompt or response text is retained.",
       "",
     ].join("\n"),
   );

package/src/commands/sessions.js ADDED Viewed

@@ -0,0 +1,29 @@
+"use strict";
+const fs = require("node:fs");
+const { buildSessionAnalytics, summarizeSessions, sessionsToCsv } = require("../lib/session-analytics");
+const { buildGitOutcomes } = require("../lib/git-outcomes");
+function option(args, name) {
+  const index = args.indexOf(name);
+  return index >= 0 ? args[index + 1] || "" : "";
+}
+async function cmdSessions(args = []) {
+  const format = option(args, "--format") || (args.includes("--csv") ? "csv" : "json");
+  const out = option(args, "--out");
+  const sessions = await buildSessionAnalytics({ force: args.includes("--refresh") });
+  if (!args.includes("--no-git")) await buildGitOutcomes(sessions);
+  const summary = summarizeSessions(sessions, { from: option(args, "--from"), to: option(args, "--to") });
+  const content = format === "csv"
+    ? sessionsToCsv(summary.sessions)
+    : `${JSON.stringify(summary, null, 2)}\n`;
+  if (out) {
+    fs.writeFileSync(out, content, { encoding: "utf8", mode: 0o600 });
+    process.stdout.write(`${out}\n`);
+  } else {
+    process.stdout.write(content);
+  }
+}
+module.exports = { cmdSessions };

package/src/lib/context-health.js ADDED Viewed

@@ -0,0 +1,124 @@
+"use strict";
+// Estimates fixed context overhead without returning file contents, prompts,
+// tool schemas, secrets, or command arguments.
+const fs = require("node:fs");
+const os = require("node:os");
+const path = require("node:path");
+const contextCache = new Map();
+function estimateTokens(text) {
+  const value = String(text || "");
+  let cjk = 0;
+  for (const char of value) if (/\p{Script=Han}|\p{Script=Hiragana}|\p{Script=Katakana}/u.test(char)) cjk += 1;
+  return Math.ceil(cjk + (value.length - cjk) / 4);
+}
+function readMetadata(filePath, kind, root) {
+  try {
+    const text = fs.readFileSync(filePath, "utf8");
+    return { kind, name: path.relative(root, filePath) || path.basename(filePath), bytes: Buffer.byteLength(text), estimated_tokens: estimateTokens(text) };
+  } catch { return null; }
+}
+function walkNamedFiles(root, targetName, limit = 500) {
+  const out = [];
+  const stack = [root];
+  while (stack.length && out.length < limit) {
+    const dir = stack.pop();
+    let entries;
+    try { entries = fs.readdirSync(dir, { withFileTypes: true }); } catch { continue; }
+    for (const entry of entries) {
+      if ([".git", "node_modules", "dist", "build"].includes(entry.name)) continue;
+      const filePath = path.join(dir, entry.name);
+      if (entry.isDirectory()) stack.push(filePath);
+      else if (entry.isFile() && entry.name === targetName) out.push(filePath);
+      if (out.length >= limit) break;
+    }
+  }
+  return out;
+}
+function countMcpServers(home, cwd) {
+  const files = [
+    path.join(home, ".claude.json"),
+    path.join(home, ".claude", "settings.json"),
+    path.join(cwd, ".mcp.json"),
+  ];
+  const names = new Set();
+  for (const filePath of files) {
+    try {
+      const data = JSON.parse(fs.readFileSync(filePath, "utf8"));
+      const servers = data.mcpServers || data.mcp_servers || {};
+      for (const name of Object.keys(servers)) names.add(name);
+    } catch { /* absent or not JSON */ }
+  }
+  try {
+    const toml = fs.readFileSync(path.join(home, ".codex", "config.toml"), "utf8");
+    for (const match of toml.matchAll(/^\s*\[mcp_servers\.([^\]]+)\]/gm)) names.add(match[1]);
+  } catch { /* absent */ }
+  return names.size;
+}
+function computeContextHealth({ home = os.homedir(), cwd = process.cwd(), env = process.env, cacheTtlMs = 5 * 60_000 } = {}) {
+  const cacheKey = `${home}\0${cwd}\0${env.TOKENTRACKER_MCP_TOOL_SCHEMA_TOKENS || ""}\0${env.TOKENTRACKER_MCP_TOOLS_PER_SERVER || ""}`;
+  const cached = contextCache.get(cacheKey);
+  if (cached && Date.now() - cached.at < cacheTtlMs) return cached.value;
+  const files = [];
+  const known = [
+    [path.join(home, ".claude", "CLAUDE.md"), "instruction", home],
+    [path.join(home, ".codex", "AGENTS.md"), "instruction", home],
+    [path.join(cwd, "CLAUDE.md"), "instruction", cwd],
+    [path.join(cwd, "AGENTS.md"), "instruction", cwd],
+  ];
+  for (const [filePath, kind, root] of known) {
+    const item = readMetadata(filePath, kind, root);
+    if (item) files.push(item);
+  }
+  const skillRoots = [
+    path.join(home, ".claude", "skills"),
+    path.join(home, ".codex", "skills"),
+    path.join(cwd, ".claude", "skills"),
+    path.join(cwd, ".agents", "skills"),
+  ];
+  for (const root of skillRoots) {
+    for (const filePath of walkNamedFiles(root, "SKILL.md")) {
+      const item = readMetadata(filePath, "skill", root);
+      if (item) files.push(item);
+    }
+  }
+  const instructionTokens = files.filter((row) => row.kind === "instruction").reduce((sum, row) => sum + row.estimated_tokens, 0);
+  const skillTokens = files.filter((row) => row.kind === "skill").reduce((sum, row) => sum + row.estimated_tokens, 0);
+  const mcpServers = countMcpServers(home, cwd);
+  const perToolSchemaTokens = Math.max(0, Number(env.TOKENTRACKER_MCP_TOOL_SCHEMA_TOKENS || 400));
+  const assumedToolsPerServer = Math.max(1, Number(env.TOKENTRACKER_MCP_TOOLS_PER_SERVER || 5));
+  const mcpSchemaTokens = mcpServers * perToolSchemaTokens * assumedToolsPerServer;
+  const total = instructionTokens + skillTokens + mcpSchemaTokens;
+  const severity = total >= 50_000 ? "high" : total >= 20_000 ? "medium" : "low";
+  const result = {
+    generated_at: new Date().toISOString(),
+    estimated_fixed_tokens: total,
+    severity,
+    breakdown: {
+      instruction_files: files.filter((row) => row.kind === "instruction").length,
+      instruction_tokens: instructionTokens,
+      skills: files.filter((row) => row.kind === "skill").length,
+      skill_tokens: skillTokens,
+      mcp_servers: mcpServers,
+      mcp_schema_tokens: mcpSchemaTokens,
+    },
+    largest_items: files.sort((a, b) => b.estimated_tokens - a.estimated_tokens).slice(0, 10),
+    provenance: {
+      confidence: "inferred",
+      source: "local-config-metadata",
+      mcp_assumption: { tools_per_server: assumedToolsPerServer, tokens_per_tool_schema: perToolSchemaTokens },
+      content_retained: false,
+    },
+  };
+  contextCache.set(cacheKey, { at: Date.now(), value: result });
+  if (contextCache.size > 8) contextCache.delete(contextCache.keys().next().value);
+  return result;
+}
+module.exports = { estimateTokens, computeContextHealth, countMcpServers };

package/src/lib/git-outcomes.js ADDED Viewed

@@ -0,0 +1,147 @@
+"use strict";
+// Conservative, metadata-only Git attribution. A commit is attributed only
+// when exactly one local AI session overlaps its author timestamp.
+const { execFile } = require("node:child_process");
+const fs = require("node:fs");
+const fsp = require("node:fs/promises");
+const os = require("node:os");
+const path = require("node:path");
+const crypto = require("node:crypto");
+function resolveAutoOutcomesPath(home = os.homedir()) {
+  return path.join(home, ".tokentracker", "tracker", "auto-outcomes.jsonl");
+}
+function readJsonl(filePath) {
+  try { return fs.readFileSync(filePath, "utf8").split("\n").filter(Boolean).map((line) => JSON.parse(line)); }
+  catch { return []; }
+}
+// Async on purpose: this runs inside the local API request path, where a
+// synchronous spawn would freeze every other endpoint for the duration of
+// each git invocation.
+function runGit(cwd, args) {
+  return new Promise((resolve) => {
+    execFile(
+      "git",
+      args,
+      { cwd, encoding: "utf8", timeout: 15_000, maxBuffer: 32 * 1024 * 1024 },
+      (error, stdout) => resolve(error ? "" : String(stdout).trim()),
+    );
+  });
+}
+async function repoRoot(cwd) {
+  if (!cwd || !fs.existsSync(cwd)) return null;
+  return (await runGit(cwd, ["rev-parse", "--show-toplevel"])) || null;
+}
+async function commitsForWindow(root, from, to) {
+  const format = "%H%x1f%aI%x1f%P%x1f%s%x1e";
+  const raw = await runGit(root, ["log", "--all", `--since=${from}`, `--until=${to}`, `--format=${format}`]);
+  if (!raw) return [];
+  return raw.split("\x1e").map((item) => item.trim()).filter(Boolean).map((item) => {
+    const [sha, timestamp, parents, subject] = item.split("\x1f");
+    return {
+      sha,
+      timestamp,
+      parent_count: String(parents || "").split(/\s+/).filter(Boolean).length,
+      reverted: /^revert\b/i.test(subject || ""),
+    };
+  }).filter((row) => row.sha && Number.isFinite(Date.parse(row.timestamp)));
+}
+async function writeAtomic(filePath, content) {
+  await fsp.mkdir(path.dirname(filePath), { recursive: true, mode: 0o700 });
+  const temp = `${filePath}.${process.pid}.${Date.now()}.tmp`;
+  await fsp.writeFile(temp, content, { encoding: "utf8", mode: 0o600 });
+  await fsp.rename(temp, filePath);
+}
+async function buildGitOutcomesInternal(sessions, { home = os.homedir(), force = false, maxAgeDays = 90 } = {}) {
+  const groups = new Map();
+  const rootCache = new Map();
+  const cutoff = Date.now() - Math.max(1, Number(maxAgeDays) || 90) * 86400_000;
+  for (const session of sessions || []) {
+    if (!session?.project_ref || !session.started_at || !session.ended_at) continue;
+    if (Date.parse(session.ended_at) < cutoff) continue;
+    let root = rootCache.get(session.project_ref);
+    if (root === undefined) {
+      root = await repoRoot(session.project_ref);
+      rootCache.set(session.project_ref, root);
+    }
+    if (!root) continue;
+    if (!groups.has(root)) groups.set(root, []);
+    groups.get(root).push(session);
+  }
+  const outputPath = resolveAutoOutcomesPath(home);
+  const metaPath = `${outputPath}.meta.json`;
+  const signatureHash = crypto.createHash("sha256");
+  for (const [root, repoSessions] of [...groups.entries()].sort(([a], [b]) => a.localeCompare(b))) {
+    signatureHash.update(`${root}\0${await runGit(root, ["for-each-ref", "--format=%(objectname)"])}\n`);
+    for (const session of repoSessions) signatureHash.update(`${session.session_hash}\0${session.ended_at}\n`);
+  }
+  const signature = signatureHash.digest("hex");
+  if (!force) {
+    try {
+      const meta = JSON.parse(fs.readFileSync(metaPath, "utf8"));
+      if (meta.version === 1 && meta.signature === signature) return readJsonl(outputPath);
+    } catch { /* first run */ }
+  }
+  const outcomes = [];
+  for (const [root, repoSessions] of groups) {
+    const start = repoSessions.reduce((min, row) => !min || row.started_at < min ? row.started_at : min, "");
+    const endMs = Math.max(...repoSessions.map((row) => Date.parse(row.ended_at))) + 60 * 60 * 1000;
+    const commits = await commitsForWindow(root, start, new Date(endMs).toISOString());
+    for (const commit of commits) {
+      const commitMs = Date.parse(commit.timestamp);
+      const candidates = repoSessions.filter((session) => {
+        const sessionStart = Date.parse(session.started_at) - 10 * 60 * 1000;
+        const sessionEnd = Date.parse(session.ended_at) + 60 * 60 * 1000;
+        return commitMs >= sessionStart && commitMs <= sessionEnd;
+      });
+      if (candidates.length !== 1) continue;
+      const session = candidates[0];
+      outcomes.push({
+        timestamp: commit.timestamp,
+        model: session.model || "unknown",
+        tool: session.source || "unknown",
+        accepted: !commit.reverted,
+        task_type: "git_commit",
+        status: commit.reverted ? "reverted" : "committed",
+        session_hash: session.session_hash,
+        commit_hash: commit.sha.slice(0, 12),
+        parent_count: commit.parent_count,
+        confidence: "heuristic",
+        methodology: "single-overlapping-session",
+      });
+    }
+  }
+  outcomes.sort((a, b) => a.timestamp.localeCompare(b.timestamp));
+  await writeAtomic(outputPath, outcomes.map((row) => JSON.stringify(row)).join("\n") + (outcomes.length ? "\n" : ""));
+  await writeAtomic(metaPath, `${JSON.stringify({ version: 1, signature, generated_at: new Date().toISOString(), max_age_days: maxAgeDays })}\n`);
+  return outcomes;
+}
+// Overlapping outcomes/session-insights requests must not spawn duplicate git
+// scans nor race the atomic sidecar write; share one build per home.
+const gitOutcomesBuilds = new Map();
+function buildGitOutcomes(sessions, options = {}) {
+  const home = path.resolve(String(options.home || os.homedir()));
+  const existing = gitOutcomesBuilds.get(home);
+  if (existing) return existing;
+  const promise = buildGitOutcomesInternal(sessions, { ...options, home });
+  gitOutcomesBuilds.set(home, promise);
+  const clear = () => {
+    if (gitOutcomesBuilds.get(home) === promise) gitOutcomesBuilds.delete(home);
+  };
+  promise.then(clear, clear);
+  return promise;
+}
+module.exports = { resolveAutoOutcomesPath, buildGitOutcomes, repoRoot, commitsForWindow };

package/src/lib/local-api.js CHANGED Viewed

@@ -1949,11 +1949,20 @@ function createLocalApiHandler({ queuePath }) {
       const from = url.searchParams.get("from") || "";
       const to = url.searchParams.get("to") || "";
       const {
-        readOutcomesData,
-        resolveOutcomesPath,
+        readAllOutcomesData,
         computeQualityPerDollar,
       } = require("./outcomes-engine");
-      const outcomes = readOutcomesData(resolveOutcomesPath());
+      // Refresh the independent metadata-only sidecars before joining. Any
+      // scanner failure degrades to the existing manual outcomes file.
+      try {
+        const { buildSessionAnalytics } = require("./session-analytics");
+        const { buildGitOutcomes } = require("./git-outcomes");
+        const sessions = await buildSessionAnalytics();
+        await buildGitOutcomes(sessions);
+      } catch (error) {
+        console.error("[outcomes] automatic Git attribution failed:", error?.message || error);
+      }
+      const outcomes = readAllOutcomesData();
       if (!outcomes.length) {
         json(res, { available: false, from, to, by_model: [], by_tool: [], totals: null });
         return true;
@@ -1964,6 +1973,39 @@ function createLocalApiHandler({ queuePath }) {
       return true;
     }
+    // --- metadata-only Claude/Codex session efficiency ---
+    if (p === "/functions/tokentracker-session-insights") {
+      const from = url.searchParams.get("from") || "";
+      const to = url.searchParams.get("to") || "";
+      const refresh = ["1", "true"].includes(url.searchParams.get("refresh"));
+      try {
+        const { buildSessionAnalytics, summarizeSessions, sessionsToCsv } = require("./session-analytics");
+        const sessions = await buildSessionAnalytics({ force: refresh });
+        const wantsCsv = url.searchParams.get("format") === "csv";
+        const includeSessions = wantsCsv || ["1", "true"].includes(url.searchParams.get("include_sessions"));
+        const result = summarizeSessions(sessions, { from, to, includeSessions });
+        if (wantsCsv) {
+          const content = sessionsToCsv(result.sessions);
+          res.statusCode = 200;
+          res.setHeader("Content-Type", "text/csv; charset=utf-8");
+          res.setHeader("Content-Disposition", "attachment; filename=tokentracker-sessions.csv");
+          res.end(content);
+          return true;
+        }
+        json(res, { from, to, ...result });
+      } catch (error) {
+        json(res, { available: false, error: error?.message || "Session analytics failed" }, 500);
+      }
+      return true;
+    }
+    // --- fixed context overhead audit (counts and estimates only) ---
+    if (p === "/functions/tokentracker-context-health") {
+      const { computeContextHealth } = require("./context-health");
+      json(res, computeContextHealth({ home: os.homedir(), cwd: process.cwd(), env: process.env }));
+      return true;
+    }
     // --- usage-heatmap ---
     if (p === "/functions/tokentracker-usage-heatmap") {
       const weeks = parseInt(url.searchParams.get("weeks") || "52", 10);

package/src/lib/outcomes-engine.js CHANGED Viewed

@@ -27,6 +27,10 @@ function resolveOutcomesPath() {
   return path.join(os.homedir(), ".tokentracker", "tracker", "outcomes.jsonl");
 }
+function resolveAutoOutcomesPath() {
+  return path.join(os.homedir(), ".tokentracker", "tracker", "auto-outcomes.jsonl");
+}
 // The ONLY fields ever lifted off an outcome record. Anything not on this list
 // — bodies, diffs, messages, arbitrary blobs — is dropped at read time. This is
 // the enforcement point for the metadata-only privacy invariant.
@@ -54,6 +58,10 @@ function sanitizeOutcome(raw) {
   if (typeof raw.task_type === "string" && raw.task_type.trim()) {
     out.task_type = raw.task_type.trim();
   }
+  for (const key of ["status", "session_hash", "commit_hash", "confidence", "methodology"]) {
+    if (typeof raw[key] === "string" && raw[key].trim()) out[key] = raw[key].trim();
+  }
+  if (Number.isFinite(Number(raw.parent_count))) out.parent_count = Number(raw.parent_count);
   return out;
 }
@@ -91,6 +99,19 @@ function readOutcomesData(outcomesPath) {
   return out;
 }
+function readAllOutcomesData(paths = [resolveOutcomesPath(), resolveAutoOutcomesPath()]) {
+  const dedup = new Map();
+  for (const outcomePath of paths) {
+    for (const row of readOutcomesData(outcomePath)) {
+      const key = row.commit_hash
+        ? `commit:${row.commit_hash}`
+        : `${row.timestamp}|${row.model}|${row.tool}|${row.task_type || ""}`;
+      dedup.set(key, row);
+    }
+  }
+  return [...dedup.values()];
+}
 function dayOf(value) {
   return typeof value === "string" ? value.slice(0, 10) : "";
 }
@@ -224,7 +245,9 @@ function computeQualityPerDollar(queueRows, outcomes, { from = "", to = "" } = {
 module.exports = {
   resolveOutcomesPath,
+  resolveAutoOutcomesPath,
   sanitizeOutcome,
   readOutcomesData,
+  readAllOutcomesData,
   computeQualityPerDollar,
 };