tokenmaxxing-cli 0.1.0

package/dist/store.js

@@ -0,0 +1,59 @@
+import { appendFileSync, mkdirSync, statSync } from 'node:fs';
+import { dirname } from 'node:path';
+import { bucketKey } from './bucket.js';
+import { files } from './paths.js';
+import { writeFileAtomic, isFile } from './fsutil.js';
+import { scanLines, parseLine } from './lines.js';
+import { COUNT_FIELDS, SOURCES } from './types.js';
+export const COMPACT_THRESHOLD = 5 * 1024 * 1024;
+/** Only these keys ever leave the machine (push) or get written. */
+export function cleanRow(b) {
+    const out = { v: 1, ts: b.ts, source: b.source, model: b.model };
+    for (const f of COUNT_FIELDS)
+        out[f] = typeof b[f] === 'number' && Number.isFinite(b[f]) ? b[f] : 0;
+    return out;
+}
+function valid(o) {
+    return o && o.v === 1 && typeof o.ts === 'string' && SOURCES.includes(o.source) && typeof o.model === 'string';
+}
+/** Read buckets.jsonl keeping the last row per (ts, source, model). */
+export async function loadBuckets(path = files.buckets()) {
+    const rows = new Map();
+    let lines = 0;
+    let bad = 0;
+    if (!isFile(path))
+        return { rows, lines, bad, bytes: 0 };
+    const size = statSync(path).size;
+    await scanLines(path, 0, size, (line) => {
+        lines++;
+        const o = parseLine(line);
+        if (!valid(o)) {
+            bad++;
+            return;
+        }
+        rows.set(bucketKey(o), cleanRow(o));
+    });
+    return { rows, lines, bad, bytes: size };
+}
+export function appendBuckets(rows, path = files.buckets()) {
+    if (!rows.length)
+        return;
+    mkdirSync(dirname(path), { recursive: true });
+    appendFileSync(path, rows.map((r) => JSON.stringify(cleanRow(r))).join('\n') + '\n');
+}
+export function sortRows(rows) {
+    return [...rows].sort((a, b) => a.ts < b.ts ? -1 : a.ts > b.ts ? 1 : a.source < b.source ? -1 : a.source > b.source ? 1 : a.model < b.model ? -1 : a.model > b.model ? 1 : 0);
+}
+/** Rewrite the file keeping only the last row per key. */
+export function compactBuckets(rows, path = files.buckets()) {
+    const body = sortRows(rows.values()).map((r) => JSON.stringify(cleanRow(r))).join('\n');
+    writeFileAtomic(path, body ? body + '\n' : '');
+}
+export function bucketsFileSize(path = files.buckets()) {
+    try {
+        return statSync(path).size;
+    }
+    catch {
+        return 0;
+    }
+}

package/dist/sync.js

@@ -0,0 +1,115 @@
+import { closeSync, mkdirSync, openSync, rmSync, statSync, writeSync } from 'node:fs';
+import { addInto, emptyBucket, bucketKey, isZero, BucketAccumulator } from './bucket.js';
+import { loadConfig } from './config.js';
+import { loadCursors, saveCursors, sourceCursor } from './cursors.js';
+import { BoundedSet } from './dedup.js';
+import { files, tmxHome } from './paths.js';
+import { appendBuckets, bucketsFileSize, compactBuckets, COMPACT_THRESHOLD, loadBuckets } from './store.js';
+import { DEDUP_LIMIT, newStats } from './parsers/context.js';
+import * as claude from './parsers/claude.js';
+import * as codex from './parsers/codex.js';
+import * as gemini from './parsers/gemini.js';
+import * as cursor from './parsers/cursor.js';
+import { COUNT_FIELDS } from './types.js';
+export const PARSERS = {
+    claude: claude.parse,
+    codex: codex.parse,
+    gemini: gemini.parse,
+    cursor: cursor.parse,
+};
+const LOCK_STALE_MS = 10 * 60 * 1000;
+function acquireLock() {
+    mkdirSync(tmxHome(), { recursive: true });
+    const path = files.lock();
+    for (let attempt = 0; attempt < 2; attempt++) {
+        try {
+            const fd = openSync(path, 'wx');
+            writeSync(fd, String(process.pid));
+            closeSync(fd);
+            return true;
+        }
+        catch {
+            try {
+                if (Date.now() - statSync(path).mtimeMs > LOCK_STALE_MS) {
+                    rmSync(path, { force: true });
+                    continue;
+                }
+            }
+            catch {
+                continue;
+            }
+            return false;
+        }
+    }
+    return false;
+}
+function releaseLock() {
+    rmSync(files.lock(), { force: true });
+}
+/** Incrementally parse every enabled source and append replacement rows for affected hours. */
+export async function sync(cfg = loadConfig(), onProgress) {
+    const t0 = Date.now();
+    if (!acquireLock())
+        return { ms: 0, rowsWritten: 0, perSource: {}, compacted: false, skippedLocked: true };
+    try {
+        const cursors = loadCursors();
+        const deltas = new Map();
+        const perSource = {};
+        for (const name of Object.keys(PARSERS)) {
+            const sc = cfg.sources[name];
+            if (!sc?.enabled || !sc.paths.length)
+                continue;
+            if (name === 'cursor')
+                continue; // activity only: nothing to read in v1 (see parsers/cursor.ts)
+            onProgress?.(`scanning ${name}…`);
+            const cur = sourceCursor(cursors, name);
+            const dedup = new BoundedSet(DEDUP_LIMIT, cur.dedup);
+            const ctx = { paths: sc.paths, cursor: cur, dedup, acc: new BucketAccumulator(), stats: newStats() };
+            const rows = await PARSERS[name](ctx);
+            cur.dedup = dedup.toJSON();
+            cur.badLines += ctx.stats.badLines;
+            cur.lastSync = new Date().toISOString();
+            cur.lastFilesScanned = ctx.stats.filesSeen;
+            cur.lastFilesChanged = ctx.stats.filesChanged;
+            perSource[name] = ctx.stats;
+            for (const r of rows) {
+                if (isZero(r))
+                    continue;
+                const k = bucketKey(r);
+                const d = deltas.get(k);
+                if (d)
+                    addInto(d, r);
+                else
+                    deltas.set(k, { ...r });
+            }
+        }
+        let rowsWritten = 0;
+        let compacted = false;
+        if (deltas.size) {
+            const existing = await loadBuckets();
+            const out = [];
+            for (const [k, d] of deltas) {
+                const next = { ...(existing.rows.get(k) ?? emptyBucket(d.ts, d.source, d.model)) };
+                addInto(next, d);
+                // A replaced Claude contribution is subtracted; never let a row go negative if the stores disagree.
+                for (const f of COUNT_FIELDS)
+                    if (next[f] < 0)
+                        next[f] = 0;
+                existing.rows.set(k, next);
+                out.push(next);
+            }
+            appendBuckets(out);
+            rowsWritten = out.length;
+            // Compact only when there is something to drop, so a large-but-dense file isn't rewritten every sync.
+            if (bucketsFileSize() > COMPACT_THRESHOLD && existing.lines + out.length > existing.rows.size * 1.2) {
+                compactBuckets(existing.rows);
+                compacted = true;
+            }
+        }
+        saveCursors(cursors);
+        return { ms: Date.now() - t0, rowsWritten, perSource, compacted };
+    }
+    finally {
+        releaseLock();
+    }
+}

package/dist/types.js

@@ -0,0 +1,9 @@
+export const SOURCES = ['claude', 'codex', 'gemini', 'cursor'];
+export const PROVIDER_SOURCE = {
+    claude: 'claude',
+    openai: 'codex',
+    cursor: 'cursor',
+    google: 'gemini',
+};
+export const TOKEN_FIELDS = ['input', 'cache_read', 'cache_write_5m', 'cache_write_1h', 'output', 'reasoning'];
+export const COUNT_FIELDS = [...TOKEN_FIELDS, 'requests', 'conversations'];

package/dist/verify.js

@@ -0,0 +1,118 @@
+import { execFile } from 'node:child_process';
+import { fmtInt, fmtUsd, table } from './format.js';
+import { inPeriod } from './period.js';
+import { cost, resolve } from './pricing/index.js';
+export const TOLERANCE = 0.01;
+const METRICS = ['input', 'output', 'cache_write', 'cache_read'];
+/** Output is informational: ccusage keeps the first line of a multi-line message, we keep the final usage. */
+const STRICT = ['input', 'cache_write', 'cache_read'];
+export const OUTPUT_NOTE = 'expected higher than ccusage: tokenmaxxing counts the final usage of multi-line messages';
+const zero = () => ({ input: 0, output: 0, cache_write: 0, cache_read: 0, cost: 0 });
+export function ccusageTotals(j, sinceDate) {
+    const m = new Map();
+    for (const d of j.daily ?? []) {
+        if (d.date < sinceDate)
+            continue;
+        for (const b of d.modelBreakdowns ?? []) {
+            if (!b.modelName || b.modelName === '<synthetic>')
+                continue;
+            const t = m.get(b.modelName) ?? zero();
+            t.input += b.inputTokens ?? 0;
+            t.output += b.outputTokens ?? 0;
+            t.cache_write += b.cacheCreationTokens ?? 0;
+            t.cache_read += b.cacheReadTokens ?? 0;
+            t.cost += b.cost ?? 0;
+            m.set(b.modelName, t);
+        }
+    }
+    return m;
+}
+export function ourTotals(buckets, period) {
+    const m = new Map();
+    for (const b of buckets) {
+        if (b.source !== 'claude' || !inPeriod(b.ts, period))
+            continue;
+        const t = m.get(b.model) ?? zero();
+        t.input += b.input;
+        t.output += b.output;
+        t.cache_write += b.cache_write_5m + b.cache_write_1h;
+        t.cache_read += b.cache_read;
+        const r = resolve(b.model);
+        if (r)
+            t.cost += cost(b, r);
+        m.set(b.model, t);
+    }
+    return m;
+}
+function delta(ours, theirs) {
+    if (ours === theirs)
+        return 0;
+    return (ours - theirs) / Math.max(Math.abs(theirs), 1);
+}
+export function compare(ours, theirs) {
+    const models = [...new Set([...ours.keys(), ...theirs.keys()])].sort();
+    const rows = [];
+    const tOurs = zero();
+    const tTheirs = zero();
+    let pass = true;
+    const failed = [];
+    const status = (k, d, label) => {
+        if (!STRICT.includes(k))
+            return '(info)';
+        if (Math.abs(d) <= TOLERANCE)
+            return 'ok';
+        pass = false;
+        failed.push(label);
+        return 'FAIL';
+    };
+    for (const model of models) {
+        const a = ours.get(model) ?? zero();
+        const b = theirs.get(model) ?? zero();
+        if (METRICS.every((k) => a[k] === 0 && b[k] === 0))
+            continue;
+        METRICS.forEach((k, i) => {
+            const d = delta(a[k], b[k]);
+            rows.push([i === 0 ? model : '', k, fmtInt(a[k]), fmtInt(b[k]), fmtPct(d), status(k, d, `${model} ${k}`)]);
+        });
+        rows.push(['', 'cost', fmtUsd(a.cost), fmtUsd(b.cost), fmtPct(delta(a.cost, b.cost)), '(info)']);
+        for (const k of [...METRICS, 'cost']) {
+            tOurs[k] += a[k];
+            tTheirs[k] += b[k];
+        }
+    }
+    METRICS.forEach((k, i) => {
+        const d = delta(tOurs[k], tTheirs[k]);
+        rows.push([i === 0 ? 'TOTAL' : '', k, fmtInt(tOurs[k]), fmtInt(tTheirs[k]), fmtPct(d), status(k, d, `TOTAL ${k}`)]);
+    });
+    rows.push(['', 'cost', fmtUsd(tOurs.cost), fmtUsd(tTheirs.cost), fmtPct(delta(tOurs.cost, tTheirs.cost)), '(info)']);
+    const lines = table(['MODEL', 'METRIC', 'TOKENMAXXING', 'CCUSAGE', 'DELTA', ''], rows, ['l', 'l', 'r', 'r', 'r', 'l']);
+    lines.push('');
+    lines.push(pass
+        ? `PASS — input, cache_write and cache_read within ${TOLERANCE * 100}% of ccusage.`
+        : `FAIL — outside ${TOLERANCE * 100}% tolerance: ${failed.join(', ')}`);
+    const outDelta = delta(tOurs.output, tTheirs.output);
+    lines.push(`Output ${fmtPct(outDelta)} vs ccusage (informational, not part of pass/fail): ${OUTPUT_NOTE}.`);
+    lines.push('Cost is informational and differs by design: ccusage prices every cache write at the 5-minute rate, while tokenmaxxing', 'prices 1-hour cache writes at the 1-hour rate, and uses the bundled pricing snapshot instead of live prices.');
+    return { pass, lines };
+}
+export function fmtPct(d) {
+    const p = d * 100;
+    return (p >= 0 ? '+' : '') + p.toFixed(2) + '%';
+}
+export function runCcusage(sinceYmd) {
+    return new Promise((resolveP) => {
+        execFile('ccusage', ['daily', '--since', sinceYmd, '--json'], { maxBuffer: 512 * 1024 * 1024, timeout: 10 * 60 * 1000 }, (err, stdout, stderr) => {
+            if (err) {
+                const missing = err.code === 'ENOENT';
+                resolveP({ ok: false, missing, error: missing ? 'ccusage not found on PATH' : (stderr || err.message).trim() });
+                return;
+            }
+            try {
+                resolveP({ ok: true, json: JSON.parse(stdout) });
+            }
+            catch (e) {
+                resolveP({ ok: false, missing: false, error: `could not parse ccusage output: ${e.message}` });
+            }
+        });
+    });
+}

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "tokenmaxxing-cli",
+  "version": "0.1.0",
+  "description": "See how much API-equivalent value your AI coding subscriptions deliver. Reads local Claude Code / Codex / Gemini CLI logs only. Zero dependencies, no telemetry.",
+  "type": "module",
+  "bin": {
+    "tokenmaxxing": "dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "build": "node scripts/clean.mjs && tsc -p tsconfig.json && node scripts/copy-assets.mjs",
+    "pretest": "npm run build",
+    "test": "node --test test/*.test.mjs",
+    "update-pricing": "node scripts/update-pricing.mjs",
+    "prepack": "npm run build"
+  },
+  "keywords": [
+    "claude-code",
+    "codex",
+    "gemini-cli",
+    "tokens",
+    "usage",
+    "cost",
+    "roi"
+  ],
+  "homepage": "https://tokenmaxxing.fyi",
+  "license": "MIT",
+  "devDependencies": {
+    "@types/node": "^20.19.0",
+    "typescript": "^7.0.2"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/soycarts/tokenmaxxing.git",
+    "directory": "packages/cli"
+  },
+  "bugs": {
+    "url": "https://github.com/soycarts/tokenmaxxing/issues"
+  }
+}