tokenmaxxing-cli 0.1.0

package/dist/format.js

@@ -0,0 +1,49 @@
+/** 950 → "950", 2900 → "2.9k", 317_500_000 → "317.5M", 23e9 → "23.0B". */
+export function fmtTokens(n) {
+    const a = Math.abs(n);
+    if (a < 1000)
+        return String(Math.round(n));
+    if (a < 1e6)
+        return (n / 1e3).toFixed(1) + 'k';
+    if (a < 1e9)
+        return (n / 1e6).toFixed(1) + 'M';
+    if (a < 1e12)
+        return (n / 1e9).toFixed(1) + 'B';
+    return (n / 1e12).toFixed(1) + 'T';
+}
+/** 4476.25 → "$4,476.25" */
+export function fmtUsd(n, decimals = 2) {
+    const sign = n < 0 ? '-' : '';
+    const [int, frac] = Math.abs(n).toFixed(decimals).split('.');
+    return `${sign}$${int.replace(/\B(?=(\d{3})+(?!\d))/g, ',')}${frac ? '.' + frac : ''}`;
+}
+export function fmtInt(n) {
+    return Math.round(n).toLocaleString('en-US');
+}
+/** 20 → "$20", 1020 → "$1,020", 19.99 → "$19.99" */
+export function fmtPrice(n) {
+    return fmtUsd(n, Number.isInteger(n) ? 0 : 2);
+}
+export function padEnd(s, w) {
+    return s.length >= w ? s : s + ' '.repeat(w - s.length);
+}
+export function padStart(s, w) {
+    return s.length >= w ? s : ' '.repeat(w - s.length) + s;
+}
+/** Render rows as a fixed-width table. `align[i]` is 'l' or 'r'. */
+export function table(header, rows, align, gap = 3) {
+    const widths = header.map((h, i) => Math.max(h.length, ...rows.map((r) => (r[i] ?? '').length)));
+    const line = (cells) => cells
+        .map((c, i) => (align[i] === 'r' ? padStart(c ?? '', widths[i]) : padEnd(c ?? '', widths[i])))
+        .join(' '.repeat(gap))
+        .replace(/\s+$/, '');
+    return [line(header), ...rows.map(line)];
+}
+/** Local calendar date YYYY-MM-DD for an instant. */
+export function localDate(d) {
+    const x = new Date(d);
+    const y = x.getFullYear();
+    const m = String(x.getMonth() + 1).padStart(2, '0');
+    const day = String(x.getDate()).padStart(2, '0');
+    return `${y}-${m}-${day}`;
+}

package/dist/fsutil.js

@@ -0,0 +1,61 @@
+import { mkdirSync, readFileSync, renameSync, writeFileSync, existsSync, statSync } from 'node:fs';
+import { readdir } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+export function readJson(path, fallback) {
+    try {
+        return JSON.parse(readFileSync(path, 'utf8'));
+    }
+    catch {
+        return fallback;
+    }
+}
+/** Write atomically (tmp file + rename). */
+export function writeFileAtomic(path, data) {
+    mkdirSync(dirname(path), { recursive: true });
+    const tmp = `${path}.${process.pid}.tmp`;
+    writeFileSync(tmp, data);
+    renameSync(tmp, path);
+}
+export function writeJsonAtomic(path, value, pretty = true) {
+    writeFileAtomic(path, JSON.stringify(value, null, pretty ? 2 : undefined) + '\n');
+}
+export function isDir(p) {
+    try {
+        return statSync(p).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+export function isFile(p) {
+    try {
+        return statSync(p).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+export { existsSync };
+/** Recursively list files under `dir` whose basename passes `match`. Missing dirs yield []. Symlinked dirs are not followed. */
+export async function walkFiles(dir, match) {
+    const out = [];
+    const stack = [dir];
+    while (stack.length) {
+        const d = stack.pop();
+        let entries;
+        try {
+            entries = await readdir(d, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const e of entries) {
+            const full = join(d, e.name);
+            if (e.isDirectory())
+                stack.push(full);
+            else if (e.isFile() && match(e.name, full))
+                out.push(full);
+        }
+    }
+    return out.sort();
+}

package/dist/hook.js

@@ -0,0 +1,194 @@
+import { copyFileSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { isDir, isFile } from './fsutil.js';
+import { claudeCandidateRoots, codexHome, home } from './paths.js';
+import { confirm, lineDiff } from './prompt.js';
+export const HOOK_COMMAND = 'npx -y tokenmaxxing-cli sync --quiet';
+export const CODEX_NOTIFY_LINE = 'notify = ["npx","-y","tokenmaxxing-cli","sync","--quiet"]';
+const BACKUP_SUFFIX = '.tokenmaxxing.bak';
+export function claudeSettingsPath() {
+    const env = process.env.CLAUDE_CONFIG_DIR;
+    const root = env && env.trim() ? env.split(',')[0].trim() : claudeCandidateRoots().at(-1) ?? join(home(), '.claude');
+    return join(root, 'settings.json');
+}
+export function codexConfigPath() {
+    return join(codexHome(), 'config.toml');
+}
+function isOurEntry(e) {
+    return (!!e &&
+        Array.isArray(e.hooks) &&
+        e.hooks.some((h) => h && h.type === 'command' && h.command === HOOK_COMMAND));
+}
+export function claudeHasHook(settings) {
+    const stop = settings?.hooks?.Stop;
+    return Array.isArray(stop) && stop.some(isOurEntry);
+}
+function detectIndent(text) {
+    const m = /\n([ \t]+)"/.exec(text);
+    if (!m)
+        return 2;
+    return m[1].includes('\t') ? '\t' : m[1].length;
+}
+export function addClaudeHook(settings) {
+    const next = structuredClone(settings ?? {});
+    if (!next.hooks || typeof next.hooks !== 'object')
+        next.hooks = {};
+    if (!Array.isArray(next.hooks.Stop))
+        next.hooks.Stop = [];
+    next.hooks.Stop.push({ matcher: '', hooks: [{ type: 'command', command: HOOK_COMMAND }] });
+    return next;
+}
+/** Remove exactly the entry `install` added (and containers left empty by that removal). */
+export function removeClaudeHook(settings) {
+    const next = structuredClone(settings ?? {});
+    const stop = next?.hooks?.Stop;
+    if (!Array.isArray(stop))
+        return next;
+    next.hooks.Stop = stop.filter((e) => !(isOurEntry(e) && e.hooks.length === 1 && (e.matcher === '' || e.matcher === undefined)));
+    // If our command was merged into a larger entry by hand, drop only our command from it.
+    next.hooks.Stop = next.hooks.Stop.filter((e) => {
+        if (!isOurEntry(e))
+            return true;
+        e.hooks = e.hooks.filter((h) => !(h?.type === 'command' && h.command === HOOK_COMMAND));
+        return e.hooks.length > 0;
+    });
+    if (!next.hooks.Stop.length)
+        delete next.hooks.Stop;
+    if (!Object.keys(next.hooks).length)
+        delete next.hooks;
+    return next;
+}
+const NOTIFY_KEY = /^\s*notify\s*=/m;
+export function codexHasNotify(toml) {
+    return NOTIFY_KEY.test(toml);
+}
+export function codexHasOurNotify(toml) {
+    return toml.split('\n').some((l) => l.trim() === CODEX_NOTIFY_LINE);
+}
+/** Insert the top-level `notify` key before the first [table] so TOML keeps it at the root. */
+export function addCodexNotify(toml) {
+    const lines = toml === '' ? [] : toml.split('\n');
+    const idx = lines.findIndex((l) => /^\s*\[/.test(l));
+    const insert = ['# added by `tokenmaxxing hook install` (remove with `tokenmaxxing hook uninstall`)', CODEX_NOTIFY_LINE];
+    if (idx === -1) {
+        const body = toml === '' || toml.endsWith('\n') ? toml : toml + '\n';
+        return body + insert.join('\n') + '\n';
+    }
+    lines.splice(idx, 0, ...insert, '');
+    return lines.join('\n');
+}
+export function removeCodexNotify(toml) {
+    const lines = toml.split('\n');
+    const out = [];
+    for (let i = 0; i < lines.length; i++) {
+        if (lines[i].trim() === CODEX_NOTIFY_LINE) {
+            if (out.length && out[out.length - 1].startsWith('# added by `tokenmaxxing hook install`'))
+                out.pop();
+            if (lines[i + 1] === '' && /^\s*\[/.test(lines[i + 2] ?? ''))
+                i++; // blank line install added
+            continue;
+        }
+        out.push(lines[i]);
+    }
+    return out.join('\n');
+}
+function readText(path) {
+    return isFile(path) ? readFileSync(path, 'utf8') : '';
+}
+function planClaude(action, log) {
+    const path = claudeSettingsPath();
+    if (!isDir(dirname(path))) {
+        log(`Claude Code: ${dirname(path)} not found — skipped.`);
+        return null;
+    }
+    const before = readText(path);
+    let obj = {};
+    try {
+        obj = before.trim() ? JSON.parse(before) : {};
+    }
+    catch {
+        log(`Claude Code: ${path} is not valid JSON — not touching it.`);
+        return null;
+    }
+    const has = claudeHasHook(obj);
+    if (action === 'install' && has) {
+        log(`Claude Code: Stop hook already installed in ${path}.`);
+        return null;
+    }
+    if (action === 'uninstall' && !has) {
+        log(`Claude Code: no tokenmaxxing Stop hook in ${path}.`);
+        return null;
+    }
+    const next = action === 'install' ? addClaudeHook(obj) : removeClaudeHook(obj);
+    const after = JSON.stringify(next, null, detectIndent(before)) + '\n';
+    return { label: 'Claude Code', path, before, after };
+}
+function planCodex(action, log) {
+    const path = codexConfigPath();
+    if (!isDir(dirname(path))) {
+        log(`Codex: ${dirname(path)} not found — skipped.`);
+        return null;
+    }
+    const before = readText(path);
+    if (action === 'install') {
+        if (codexHasOurNotify(before)) {
+            log(`Codex: notify hook already installed in ${path}.`);
+            return null;
+        }
+        if (codexHasNotify(before)) {
+            log(`Codex: ${path} already has a \`notify\` command, so tokenmaxxing will not edit it.\n` +
+                `  To sync after Codex turns too, make your notify program also run:  ${HOOK_COMMAND}`);
+            return null;
+        }
+        return { label: 'Codex', path, before, after: addCodexNotify(before) };
+    }
+    if (!codexHasOurNotify(before)) {
+        log(`Codex: no tokenmaxxing notify hook in ${path}.`);
+        return null;
+    }
+    return { label: 'Codex', path, before, after: removeCodexNotify(before) };
+}
+export async function hookCommand(sub, opts, log = console.log) {
+    if (sub === 'status' || sub === undefined) {
+        const cp = claudeSettingsPath();
+        let claudeOn = false;
+        try {
+            claudeOn = claudeHasHook(JSON.parse(readText(cp) || '{}'));
+        }
+        catch {
+            /* invalid json */
+        }
+        const xp = codexConfigPath();
+        const t = readText(xp);
+        log(`Claude Code Stop hook: ${claudeOn ? 'installed' : 'not installed'}  (${cp})`);
+        log(`Codex notify hook:     ${codexHasOurNotify(t) ? 'installed' : codexHasNotify(t) ? 'not installed (another notify command is configured)' : 'not installed'}  (${xp})`);
+        if (sub === undefined)
+            log('\nUsage: tokenmaxxing hook install|uninstall|status [--yes]');
+        return 0;
+    }
+    if (sub !== 'install' && sub !== 'uninstall') {
+        log('Usage: tokenmaxxing hook install|uninstall|status [--yes]');
+        return 1;
+    }
+    const edits = [planClaude(sub, log), planCodex(sub, log)].filter((e) => !!e);
+    if (!edits.length)
+        return 0;
+    for (const e of edits) {
+        log(`\n${e.label}: ${e.before ? 'edit' : 'create'} ${e.path}`);
+        log(lineDiff(e.before, e.after));
+    }
+    log('');
+    const ok = opts.yes || (await confirm(`Apply ${edits.length === 1 ? 'this change' : 'these changes'}?`));
+    if (!ok) {
+        log(process.stdin.isTTY ? 'Aborted — nothing was changed.' : 'Nothing was changed. Re-run with --yes to apply.');
+        return opts.yes ? 0 : 1;
+    }
+    for (const e of edits) {
+        if (sub === 'install' && e.before)
+            copyFileSync(e.path, e.path + BACKUP_SUFFIX);
+        mkdirSync(dirname(e.path), { recursive: true });
+        writeFileSync(e.path, e.after);
+        log(`${sub === 'install' ? 'Installed' : 'Removed'}: ${e.path}${sub === 'install' && e.before ? `  (backup: ${e.path + BACKUP_SUFFIX})` : ''}`);
+    }
+    return 0;
+}

package/dist/lines.js

@@ -0,0 +1,61 @@
+import { createReadStream } from 'node:fs';
+const NL = 10;
+const CR = 13;
+/**
+ * Stream `path` from byte `start` up to `endExclusive`, calling `onLine` for every newline-terminated line
+ * (without the trailing \n / \r\n). Never loads the whole file: only the current chunk and any line that
+ * spans chunks are held in memory.
+ */
+export async function scanLines(path, start, endExclusive, onLine) {
+    if (endExclusive <= start)
+        return { end: start, tail: null };
+    const stream = createReadStream(path, { start, end: endExclusive - 1, highWaterMark: 1 << 20 });
+    let pending = [];
+    let pendingLen = 0;
+    let consumed = start; // offset of the first byte not yet emitted as part of a complete line
+    let pos = start; // absolute offset of current chunk start
+    for await (const chunk of stream) {
+        let from = 0;
+        let idx = chunk.indexOf(NL, from);
+        while (idx !== -1) {
+            let line;
+            if (pendingLen) {
+                pending.push(chunk.subarray(from, idx));
+                line = Buffer.concat(pending, pendingLen + (idx - from));
+                pending = [];
+                pendingLen = 0;
+            }
+            else {
+                line = chunk.subarray(from, idx);
+            }
+            if (line.length && line[line.length - 1] === CR)
+                line = line.subarray(0, line.length - 1);
+            if (line.length)
+                onLine(line);
+            consumed = pos + idx + 1;
+            from = idx + 1;
+            idx = chunk.indexOf(NL, from);
+        }
+        if (from < chunk.length) {
+            // Copy so we don't pin the 1MB chunk for a small tail.
+            const rest = Buffer.from(chunk.subarray(from));
+            pending.push(rest);
+            pendingLen += rest.length;
+        }
+        pos += chunk.length;
+    }
+    const tail = pendingLen ? Buffer.concat(pending, pendingLen) : null;
+    return { end: consumed, tail };
+}
+/** Cheap substring test on a raw line before paying for JSON.parse. */
+export function has(line, needle) {
+    return line.indexOf(needle) !== -1;
+}
+export function parseLine(line) {
+    try {
+        return JSON.parse(line.toString('utf8'));
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/parsers/claude.js

@@ -0,0 +1,203 @@
+import { stat } from 'node:fs/promises';
+import { join, sep } from 'node:path';
+import { BoundedSet } from '../dedup.js';
+import { hourOf } from '../bucket.js';
+import { isFile, walkFiles } from '../fsutil.js';
+import { has, parseLine, scanLines } from '../lines.js';
+import { DEDUP_LIMIT, RECENT_LIMIT, num } from './context.js';
+const USAGE = Buffer.from('"usage"');
+const USER = Buffer.from('"type":"user"');
+const USER_SPACED = Buffer.from('"type": "user"');
+const SUBAGENTS = `${sep}subagents${sep}`;
+const MAX_PENDING = 50;
+/** All Claude Code transcript files (including subagents/) under each root's projects/ dir. */
+export async function claudeFiles(roots) {
+    const out = [];
+    for (const root of roots) {
+        out.push(...(await walkFiles(join(root, 'projects'), (n) => n.endsWith('.jsonl'))));
+    }
+    return [...new Set(out)];
+}
+/** Map a Claude `message.usage` object to our token fields; null when every counter is zero. */
+export function claudeUsage(u) {
+    const input = num(u.input_tokens);
+    const output = num(u.output_tokens);
+    const cacheRead = num(u.cache_read_input_tokens);
+    const cacheCreation = num(u.cache_creation_input_tokens);
+    let w5;
+    let w1;
+    if (u.cache_creation && typeof u.cache_creation === 'object') {
+        w5 = num(u.cache_creation.ephemeral_5m_input_tokens);
+        w1 = num(u.cache_creation.ephemeral_1h_input_tokens);
+        // Model-fallback responses report `cache_creation` for the first iteration but the top-level
+        // total for the final one. The total wins (as in ccusage); keep the split's 5m/1h ratio.
+        if (u.cache_creation_input_tokens !== undefined && w5 + w1 !== cacheCreation) {
+            const split = w5 + w1;
+            w1 = split > 0 ? Math.round((cacheCreation * w1) / split) : 0;
+            w5 = cacheCreation - w1;
+        }
+    }
+    else {
+        w5 = cacheCreation;
+        w1 = 0;
+    }
+    if (input + output + cacheRead + w5 + w1 === 0)
+        return null;
+    return { input, cache_read: cacheRead, cache_write_5m: w5, cache_write_1h: w1, output, reasoning: 0 };
+}
+const totalOf = (u) => u.input + u.cache_read + u.cache_write_5m + u.cache_write_1h + u.output;
+const negate = (u) => ({
+    input: -u.input, cache_read: -u.cache_read, cache_write_5m: -u.cache_write_5m,
+    cache_write_1h: -u.cache_write_1h, output: -u.output, reasoning: -u.reasoning,
+});
+function loadRecent(rows) {
+    const m = new Map();
+    for (const r of rows ?? []) {
+        if (!Array.isArray(r) || r.length < 8)
+            continue;
+        const usage = { input: r[3], cache_read: r[4], cache_write_5m: r[5], cache_write_1h: r[6], output: r[7], reasoning: 0 };
+        m.set(r[0], { hour: r[1], model: r[2], usage, total: totalOf(usage) });
+    }
+    return m;
+}
+function saveRecent(m) {
+    const all = [...m.entries()];
+    return all.slice(Math.max(0, all.length - RECENT_LIMIT)).map(([k, c]) => [
+        k, c.hour, c.model, c.usage.input, c.usage.cache_read, c.usage.cache_write_5m, c.usage.cache_write_1h, c.usage.output,
+    ]);
+}
+function isPrompt(content) {
+    if (typeof content === 'string')
+        return true;
+    return Array.isArray(content) && content.some((b) => b && typeof b === 'object' && b.type === 'text');
+}
+export async function parse(ctx) {
+    const { cursor, dedup, acc, stats } = ctx;
+    const conv = new BoundedSet(DEDUP_LIMIT, cursor.convDedup ?? []);
+    // Per-key contributions: every key seen this run, plus the most recent keys from earlier syncs.
+    const contribs = loadRecent(cursor.recent);
+    const list = await claudeFiles(ctx.paths);
+    const live = new Set(list);
+    for (const file of list) {
+        stats.filesSeen++;
+        let st;
+        try {
+            st = await stat(file);
+        }
+        catch {
+            continue;
+        }
+        const prev = cursor.files[file];
+        if (prev && prev.size === st.size && prev.mtimeMs === st.mtimeMs)
+            continue;
+        stats.filesChanged++;
+        const shrank = !!prev && st.size < prev.offset;
+        const start = prev && !shrank ? prev.offset : 0;
+        let lastModel = shrank ? undefined : prev?.model;
+        let pending = shrank ? [] : [...(prev?.pending ?? [])];
+        const isSub = file.includes(SUBAGENTS);
+        const handle = (obj) => {
+            if (!obj || typeof obj !== 'object')
+                return;
+            if (obj.type === 'assistant') {
+                const m = obj.message;
+                const model = m?.model;
+                if (!m || !m.usage || typeof model !== 'string' || !model || model === '<synthetic>')
+                    return;
+                lastModel = model;
+                if (pending.length) {
+                    for (const h of pending)
+                        acc.addConversation(h, 'claude', model);
+                    pending = [];
+                }
+                const usage = claudeUsage(m.usage);
+                if (!usage)
+                    return;
+                const hour = hourOf(obj.timestamp);
+                if (!hour) {
+                    stats.badLines++;
+                    return;
+                }
+                if (typeof m.id !== 'string' || !m.id) {
+                    acc.addUsage(hour, 'claude', model, usage);
+                    return;
+                }
+                // One message is written as several lines whose usage is cumulative: keep the largest.
+                const key = `${m.id}:${obj.requestId ?? ''}`;
+                const total = totalOf(usage);
+                const prevC = contribs.get(key);
+                if (prevC) {
+                    if (total <= prevC.total)
+                        return;
+                    acc.addUsage(prevC.hour, 'claude', prevC.model, negate(prevC.usage), -1);
+                    contribs.delete(key);
+                }
+                else if (dedup.has(key)) {
+                    return; // seen long ago; its contribution is no longer kept, so it cannot be replaced
+                }
+                dedup.add(key);
+                contribs.set(key, { hour, model, usage, total });
+                if (contribs.size > DEDUP_LIMIT * 1.25) {
+                    let excess = contribs.size - DEDUP_LIMIT;
+                    for (const k of contribs.keys()) {
+                        if (excess-- <= 0)
+                            break;
+                        contribs.delete(k);
+                    }
+                }
+                acc.addUsage(hour, 'claude', model, usage);
+            }
+            else if (obj.type === 'user' && !isSub) {
+                if (typeof obj.uuid !== 'string' || !isPrompt(obj.message?.content))
+                    return;
+                if (!conv.add(obj.uuid))
+                    return;
+                const hour = hourOf(obj.timestamp);
+                if (!hour)
+                    return;
+                // Attributed to the model of the next assistant response in this file.
+                pending.push(hour);
+                if (pending.length > MAX_PENDING)
+                    pending.shift();
+            }
+        };
+        const onLine = (line) => {
+            if (!(has(line, USAGE) || (!isSub && (has(line, USER) || has(line, USER_SPACED)))))
+                return;
+            const obj = parseLine(line);
+            if (obj === undefined) {
+                stats.badLines++;
+                return;
+            }
+            handle(obj);
+        };
+        let end = start;
+        try {
+            const res = await scanLines(file, start, st.size, onLine);
+            end = res.end;
+            stats.bytesRead += st.size - start;
+            if (res.tail) {
+                const obj = parseLine(res.tail);
+                if (obj !== undefined) {
+                    handle(obj);
+                    end = st.size;
+                }
+            }
+        }
+        catch {
+            continue; // unreadable file: leave cursor untouched, retry next sync
+        }
+        const next = { size: st.size, mtimeMs: st.mtimeMs, offset: end };
+        if (lastModel)
+            next.model = lastModel;
+        if (pending.length)
+            next.pending = pending;
+        cursor.files[file] = next;
+    }
+    for (const f of Object.keys(cursor.files))
+        if (!live.has(f) && !isFile(f))
+            delete cursor.files[f];
+    cursor.convDedup = conv.toJSON();
+    cursor.recent = saveRecent(contribs);
+    return acc.rows();
+}