@jv-k/claude-gauge 0.0.1 → 1.1.0

package/dist/tokenline.js

@@ -0,0 +1,293 @@
+#!/usr/bin/env node
+"use strict";
+// claude-gauge token line for Claude Code.
+//
+// Reports the tokens spent since your last prompt, from the session
+// transcript, as one compact line:
+//
+//   12:10 │ 4 req │ out 3.4k (1.2k think) │ cache w6.5k r1.69M │ ctx 43% ▓▓░░░ 427k
+//
+// Two ways to run it:
+//   - as a Stop hook: Claude Code pipes the hook payload on stdin and shows
+//     the line as a system message when the turn ends;
+//   - with --latest: prints the line for the calling session, for Claude to
+//     paste into its reply where hook messages are not shown.
+//
+// Switches:
+//   --show <parts>      parts to show, in order, comma-separated, from
+//                       time,req,out,cache,ctx (default: all of them)
+//   --segments <5|10>   cells in the context bar (default 5)
+//   --window <tokens>   context window size, e.g. 200k or 1m. Without it the
+//                       window is 200k, or 1M once the context passes 200k.
+//   --latest            print the line for the calling session
+//   --instruct          as a SessionStart hook: in the VS Code extension and
+//                       the desktop app, tell Claude to end each reply with
+//                       the line; in the terminal CLI, print nothing
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.INSTRUCT_HOSTS = exports.PARTS = void 0;
+exports.summarize = summarize;
+exports.parseArgs = parseArgs;
+exports.readSwitches = readSwitches;
+exports.parseSize = parseSize;
+exports.contextWindow = contextWindow;
+exports.instruction = instruction;
+const fs = require("node:fs");
+const os = require("node:os");
+const path = require("node:path");
+const PARTS = ['time', 'req', 'out', 'cache', 'ctx'];
+exports.PARTS = PARTS;
+const isPart = (name) => PARTS.includes(name);
+// The switches that take a value. parseArgs reads each of them.
+const TAKES_VALUE = ['--show', '--segments', '--window'];
+// The switches in `argv` as the token line reads them: a switch that takes a
+// value takes the next word, unless it has one after `=`. Any other word
+// stands alone.
+function readSwitches(argv) {
+    const read = [];
+    for (let i = 0; i < argv.length; i++) {
+        const start = i;
+        const [name, inline] = argv[i].split(/=(.*)/s);
+        const value = TAKES_VALUE.includes(name) ? (inline ?? argv[++i] ?? '') : '';
+        read.push({ name, value, words: argv.slice(start, i + 1) });
+    }
+    return read;
+}
+// Turns the switches into options. Unknown switches and part names are
+// ignored, so a hook never fails over a typo.
+function parseArgs(argv) {
+    const opts = { latest: false };
+    for (const { name, value } of readSwitches(argv)) {
+        switch (name) {
+            case '--show': {
+                const parts = value.split(',').map((p) => p.trim()).filter(isPart);
+                if (parts.length)
+                    opts.show = parts;
+                break;
+            }
+            case '--segments':
+                opts.segments = value;
+                break;
+            case '--window':
+                opts.window = value;
+                break;
+            case '--latest':
+                opts.latest = true;
+                break;
+            default: break;
+        }
+    }
+    return opts;
+}
+// Compact counts: 1.69M, 427k, 6.5k, 830.
+const fmt = (n) => n >= 1e6 ? `${(n / 1e6).toFixed(2)}M`
+    : n >= 1e5 ? `${Math.round(n / 1e3)}k`
+        : n >= 1e3 ? `${(n / 1e3).toFixed(1)}k`
+            : String(n);
+const SCALES = { '': 1, k: 1e3, m: 1e6 };
+// Parses "200000", "200k" or "1m" into a token count; NaN when it is none.
+function parseSize(value) {
+    const m = /^\s*(\d+(?:\.\d+)?)\s*([km]?)\s*$/i.exec(String(value ?? ''));
+    if (!m)
+        return NaN;
+    const scale = SCALES[m[2].toLowerCase()];
+    return Math.round(Number(m[1]) * scale);
+}
+// The transcript records the model but not its context window, so take the
+// window from --window when set. Otherwise assume Claude Code's default of
+// 200k, and 1M once the context is past that.
+function contextWindow(ctx, explicit) {
+    const size = parseSize(explicit);
+    if (size > 0)
+        return size;
+    return ctx > 200e3 ? 1e6 : 200e3;
+}
+// Bars come in 5 or 10 cells; anything else falls back to 5.
+const segmentsOf = (value) => (Number(value) === 10 ? 10 : 5);
+// A bar of `segments` cells over the context window.
+const bar = (pct, segments) => {
+    const filled = Math.min(segments, Math.max(0, Math.round((pct * segments) / 100)));
+    return '▓'.repeat(filled) + '░'.repeat(segments - filled);
+};
+// Local HH:MM, enough to tell runs apart in a scrollback.
+const stamp = (d) => {
+    const pad = (n) => String(n).padStart(2, '0');
+    return `${pad(d.getHours())}:${pad(d.getMinutes())}`;
+};
+// A human prompt, as opposed to a tool_result echoed back as a user record.
+function isHumanPrompt(rec) {
+    if (rec.type !== 'user' || rec.isMeta || rec.isSidechain)
+        return false;
+    const content = rec.message?.content;
+    if (typeof content === 'string')
+        return true;
+    if (Array.isArray(content))
+        return !content.some((b) => b?.type === 'tool_result');
+    return false;
+}
+function tally(records) {
+    const t = { reqs: 0, out: 0, thinking: 0, cacheWrite: 0, cacheRead: 0, ctx: 0 };
+    // The transcript writes one record per content block (thinking, text, each
+    // tool_use), and every one of them carries the whole message's usage. Count
+    // each API response once, by its message id, keeping its last record.
+    const byMessage = new Map();
+    for (const r of records) {
+        if (r.message?.usage)
+            byMessage.set(r.message.id ?? r.uuid, r);
+    }
+    for (const r of byMessage.values()) {
+        const u = r.message?.usage ?? {};
+        t.reqs += 1;
+        t.out += u.output_tokens ?? 0;
+        t.thinking += u.output_tokens_details?.thinking_tokens ?? 0;
+        t.cacheWrite += u.cache_creation_input_tokens ?? 0;
+        t.cacheRead += u.cache_read_input_tokens ?? 0;
+        // Context at the end of the run is whatever the final main-thread request
+        // carried in; subagent (sidechain) requests have their own context.
+        if (!r.isSidechain) {
+            t.ctx = (u.input_tokens ?? 0) + (u.cache_read_input_tokens ?? 0) + (u.cache_creation_input_tokens ?? 0);
+        }
+    }
+    return t;
+}
+// Builds the line from parsed transcript records; null when the run made no
+// API request yet, or when none of the chosen parts has anything to show.
+function summarize(records, { now = new Date(), window, segments, show = PARTS } = {}) {
+    let start = 0;
+    for (let i = records.length - 1; i >= 0; i--) {
+        if (isHumanPrompt(records[i])) {
+            start = i;
+            break;
+        }
+    }
+    const run = tally(records.slice(start).filter((r) => r.type === 'assistant'));
+    if (run.reqs === 0)
+        return null;
+    const build = {
+        time: () => stamp(now),
+        req: () => `${run.reqs} req`,
+        // Thinking tokens are part of output_tokens, so show them inside it.
+        out: () => (run.thinking ? `out ${fmt(run.out)} (${fmt(run.thinking)} think)` : `out ${fmt(run.out)}`),
+        cache: () => `cache w${fmt(run.cacheWrite)} r${fmt(run.cacheRead)}`,
+        ctx: () => {
+            if (!run.ctx)
+                return '';
+            const pct = (run.ctx / contextWindow(run.ctx, window)) * 100;
+            return `ctx ${Math.round(pct)}% ${bar(pct, segmentsOf(segments))} ${fmt(run.ctx)}`;
+        },
+    };
+    // A show list handed in from JavaScript may name parts the registry lacks;
+    // those render as nothing, like a part with nothing to show.
+    const anyPart = build;
+    // The same separator as the status line.
+    const line = show.map((part) => anyPart[part]?.() ?? '').filter(Boolean).join(' │ ');
+    return line || null;
+}
+function readRecords(transcriptPath) {
+    const records = [];
+    for (const line of fs.readFileSync(transcriptPath, 'utf8').split('\n')) {
+        if (!line)
+            continue;
+        try {
+            records.push(JSON.parse(line));
+        }
+        catch {
+            /* a partially flushed final line is expected */
+        }
+    }
+    return records;
+}
+// Claude Code's config folder: $CLAUDE_CONFIG_DIR when it is set and not
+// empty, else ~/.claude. The status line resolves it the same way, with its
+// own copy, because each script runs alone from the copy that setup makes.
+const configDirOf = (env, home) => env.CLAUDE_CONFIG_DIR || path.join(home, '.claude');
+function latestTranscript(cwd) {
+    const projects = path.join(configDirOf(process.env, os.homedir()), 'projects');
+    if (!fs.existsSync(projects))
+        return null;
+    // Claude Code exports the calling session's id to the commands it runs.
+    // Prefer it: with several sessions open in one project, the newest
+    // transcript is often another session's. Search every project folder, so a
+    // `cd` into a worktree does not lose the session.
+    const own = process.env.CLAUDE_CODE_SESSION_ID;
+    if (own) {
+        for (const d of fs.readdirSync(projects)) {
+            const f = path.join(projects, d, `${own}.jsonl`);
+            if (fs.existsSync(f))
+                return f;
+        }
+    }
+    const dir = path.join(projects, cwd.replace(/[/.]/g, '-'));
+    if (!fs.existsSync(dir))
+        return null;
+    const newest = fs
+        .readdirSync(dir)
+        .filter((f) => f.endsWith('.jsonl'))
+        .map((f) => path.join(dir, f))
+        .map((f) => ({ f, mtime: fs.statSync(f).mtimeMs }))
+        .sort((a, b) => b.mtime - a.mtime)[0];
+    return newest ? newest.f : null;
+}
+// --instruct: the SessionStart hook for hosts that show no hook message. In
+// the VS Code extension and the desktop app it prints an instruction that has
+// Claude end each reply with it. In the terminal CLI, where it already shows,
+// it prints nothing. Claude Code names the host in CLAUDE_CODE_ENTRYPOINT,
+// which hooks inherit; an unknown or missing value counts as a host that
+// needs nothing.
+const INSTRUCT_HOSTS = ['claude-vscode', 'claude-desktop', 'claude-desktop-3p'];
+exports.INSTRUCT_HOSTS = INSTRUCT_HOSTS;
+// A shell word: as is when plain, else in single quotes. ~ stays bare so the
+// shell expands a ~/ path.
+const shellWord = (s) => (/^[\w@%+=:,./~-]+$/.test(s) ? s : `'${s.replace(/'/g, `'\\''`)}'`);
+function instruction(argv, { host, script }) {
+    if (host === undefined || !INSTRUCT_HOSTS.includes(host))
+        return null;
+    const command = ['node', script, '--latest', ...argv.filter((a) => a !== '--instruct')].map(shellWord).join(' ');
+    return [
+        '## Token line in replies',
+        '',
+        "End every reply with the claude-gauge token line, as a copyable code block, so this panel shows what the terminal's Stop hook does:",
+        '',
+        '```sh',
+        command,
+        '```',
+        '',
+        "Run it as the last tool call of the turn, then paste its line verbatim as the final thing in the reply, in one plain code block. Skip it only if the command fails or prints nothing. Never guess the figures, and never reuse an earlier turn's line.",
+        '',
+    ].join('\n');
+}
+// This script's path as a hook command can name it: ~ for the home folder.
+const ownPath = () => process.argv[1].replace(new RegExp(`^${os.homedir()}(?=/)`), '~');
+const isMain = (typeof require !== 'undefined' && require.main === module) || (typeof Bun !== 'undefined' && Bun.main === __filename);
+if (isMain) {
+    const argv = process.argv.slice(2);
+    const { latest, ...opts } = parseArgs(argv);
+    if (argv.includes('--instruct')) {
+        const text = instruction(argv, { host: process.env.CLAUDE_CODE_ENTRYPOINT, script: ownPath() });
+        if (text)
+            process.stdout.write(text);
+    }
+    else if (latest) {
+        const t = latestTranscript(process.cwd());
+        const line = t ? summarize(readRecords(t), opts) : null;
+        if (line)
+            process.stdout.write(line + '\n');
+    }
+    else {
+        const chunks = [];
+        process.stdin.on('data', (c) => chunks.push(c));
+        process.stdin.on('end', () => {
+            let line = null;
+            try {
+                const input = JSON.parse(Buffer.concat(chunks).toString());
+                if (input.transcript_path && fs.existsSync(input.transcript_path)) {
+                    line = summarize(readRecords(input.transcript_path), opts);
+                }
+            }
+            catch {
+                /* never break the turn over a reporting hook */
+            }
+            if (line)
+                process.stdout.write(JSON.stringify({ systemMessage: line }) + '\n');
+        });
+    }
+}

package/dist/wizard.js

@@ -0,0 +1,264 @@
+"use strict";
+// The questions claude-gauge setup and configure ask when run with no bar
+// switches: take the defaults in one answer, or walk through the status
+// line's rows and parts, its bar size, theme and labels, and the token line
+// and its parts, with a preview of the status line redrawn after each
+// answer. configure starts from the bars set up now: the first answer keeps
+// them, and each question offers the value set up. It returns the switches
+// for each bar, as words, for the CLI to write; it reads and writes no
+// settings itself.
+//
+// The questions go through a WizardIo, so a test can script the answers. The
+// preview renders the payload the status line saved last, else a sample.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EndOfAnswers = exports.confirm = void 0;
+exports.runWizard = runWizard;
+exports.offerStar = offerStar;
+exports.samplePayload = samplePayload;
+exports.loadPayload = loadPayload;
+exports.previewer = previewer;
+exports.switchesFor = switchesFor;
+const fs = require("node:fs");
+const statusline_1 = require("./statusline");
+const tokenline_1 = require("./tokenline");
+// The input ended before the last question: nothing is written.
+class EndOfAnswers extends Error {
+    constructor() {
+        super('The answers ended before the last question. Nothing changed.');
+    }
+}
+exports.EndOfAnswers = EndOfAnswers;
+const MAX_ROWS = 3;
+const SEGMENTS = [5, 10];
+const DEFAULT_CHOICES = { rows: statusline_1.DEFAULT_ROWS, segments: 5, theme: 'default', labels: true, others: [] };
+// Whether two lists of parts, or of rows of parts, are the same, in order.
+const same = (a, b) => JSON.stringify(a) === JSON.stringify(b);
+// The fewest switches that give `choices`: none for the defaults, then the
+// switches the wizard does not ask about. A row not chosen yet is left out.
+function switchesFor({ rows, segments, theme, labels, others }) {
+    const chosen = rows.filter((row) => row.length);
+    const words = [];
+    if (!same(chosen, statusline_1.DEFAULT_ROWS))
+        for (const row of chosen)
+            words.push('--show', row.join(','));
+    if (segments !== 5)
+        words.push('--segments', String(segments));
+    if (theme !== 'default')
+        words.push('--theme', theme);
+    if (!labels)
+        words.push('--no-labels');
+    return [...words, ...others];
+}
+// The status line choices that `switches` give, read as the status line reads
+// them, so the last --segments or --theme wins. A part name or theme the
+// status line does not know reads as the status line shows it: left out, or
+// the default theme.
+function statusChoicesOf(switches) {
+    const status = { ...DEFAULT_CHOICES, rows: [], others: [] };
+    for (const { name, value, words } of (0, statusline_1.readSwitches)(switches)) {
+        if (name === '--show') {
+            const row = value.split(',').map((p) => p.trim()).filter((p) => statusline_1.PARTS.includes(p));
+            if (row.length)
+                status.rows.push(row);
+        }
+        else if (name === '--segments')
+            status.segments = Number(value) === 10 ? 10 : 5;
+        else if (name === '--theme')
+            status.theme = statusline_1.THEMES.includes(value.trim()) ? value.trim() : 'default';
+        else if (name === '--no-labels')
+            status.labels = false;
+        else
+            status.others.push(...words);
+    }
+    if (!status.rows.length)
+        status.rows = statusline_1.DEFAULT_ROWS;
+    return status;
+}
+const isSetUp = (installed) => installed?.statusLine !== undefined || installed?.tokenLine !== undefined;
+// The start from the bars set up, else from the factory defaults.
+function startFrom(installed) {
+    if (!isSetUp(installed))
+        return { status: DEFAULT_CHOICES, tokenLine: true, tokenSwitches: [] };
+    return {
+        status: statusChoicesOf(installed.statusLine ?? []),
+        tokenLine: installed.tokenLine !== undefined,
+        tokenSwitches: installed.tokenLine ?? [],
+    };
+}
+// Asks until `read` takes the answer: it returns the value, or a retry that
+// says why it cannot. Each `read` says what an empty answer, Enter, gives.
+async function askFor(io, question, read) {
+    for (;;) {
+        const answer = await io.ask(question);
+        if (answer === undefined)
+            throw new EndOfAnswers();
+        const value = read(answer.trim());
+        if (typeof value === 'object' && value !== null && 'retry' in value) {
+            io.write(`${value.retry}\n`);
+            continue;
+        }
+        return value;
+    }
+}
+const yesNo = (fallback) => (answer) => {
+    if (!answer)
+        return fallback;
+    if (/^y(?:es)?$/i.test(answer))
+        return true;
+    if (/^no?$/i.test(answer))
+        return false;
+    return { retry: 'Answer y or n.' };
+};
+const confirm = (io, question, fallback) => askFor(io, `${question} ${fallback ? '[Y/n]' : '[y/N]'} `, yesNo(fallback));
+exports.confirm = confirm;
+// Reads a list of parts from `known`, or `fallback` on Enter. An unknown
+// part is asked again, named, with `where` to say which parts there are.
+function readParts(fallback, known, where = 'The parts are listed above.') {
+    return (answer) => {
+        if (!answer && fallback)
+            return fallback;
+        const names = answer.split(/[\s,]+/).filter(Boolean);
+        const unknown = names.filter((n) => !known.includes(n));
+        if (unknown.length)
+            return { retry: `Unknown part${unknown.length > 1 ? 's' : ''}: ${unknown.join(', ')}. ${where}` };
+        if (!names.length)
+            return { retry: 'Name at least one part.' };
+        return [...new Set(names)];
+    };
+}
+// The parts the token line shows with `switches`, read as the token line
+// reads them: all of them without a --show it can use.
+const tokenPartsOf = (switches) => (0, tokenline_1.parseArgs)(switches).show ?? [...tokenline_1.PARTS];
+// The token line's switches for `parts`. Parts the installed switches show
+// already keep those switches as they are. Other parts drop the installed
+// --show and keep the rest. All five parts, in order, need no --show; any
+// other list goes first, as --show <parts>.
+function tokenSwitchesFor(parts, installed) {
+    if (same(parts, tokenPartsOf(installed)))
+        return installed;
+    const others = (0, tokenline_1.readSwitches)(installed).filter(({ name }) => name !== '--show').flatMap(({ words }) => words);
+    return same(parts, tokenline_1.PARTS) ? others : ['--show', parts.join(','), ...others];
+}
+// Reads the token line's parts: `all` for all five, else a list as readParts
+// reads it.
+function readTokenParts(fallback) {
+    const list = readParts(fallback, tokenline_1.PARTS, `The token line parts are ${tokenline_1.PARTS.join(', ')}.`);
+    return (answer) => (/^all$/i.test(answer) ? [...tokenline_1.PARTS] : list(answer));
+}
+async function runWizard(io, { preview, installed }) {
+    const start = startFrom(installed);
+    let status = { ...start.status };
+    let tokenLine = start.tokenLine;
+    const show = () => {
+        const rows = preview(switchesFor(status));
+        io.write(`\n${rows.split('\n').map((row) => `  ${row}`).join('\n')}\n`);
+        io.write(`Token line: ${tokenLine ? 'on, when each turn ends' : 'off'}\n\n`);
+    };
+    if (isSetUp(installed)) {
+        io.write(installed.statusLine ? 'The status line as set up now:\n' : 'The status line is not set up. With the defaults it shows:\n');
+        show();
+        if (await confirm(io, 'Keep the current bars as they are?', true))
+            return {};
+    }
+    else {
+        io.write('The status line with the defaults:\n');
+        show();
+        if (await confirm(io, 'Use the defaults: both bars, with the parts above?', true))
+            return { statusLine: [], tokenLine: [] };
+    }
+    // A row set up, else the default row there.
+    const rowAt = (i) => start.status.rows[i] ?? statusline_1.DEFAULT_ROWS[i];
+    // More rows than the wizard offers stay possible when that many are set up.
+    const rowsNow = start.status.rows.length;
+    const maxRows = Math.max(MAX_ROWS, rowsNow);
+    io.write(`\nThe parts: ${statusline_1.PARTS.join(', ')}.\nREADME.md says what each shows. Press Enter to keep the value in brackets.\n`);
+    const count = await askFor(io, `How many status line rows, 1 to ${maxRows}? [${rowsNow}] `, (answer) => {
+        const n = answer ? Number(answer) : rowsNow;
+        return Number.isInteger(n) && n >= 1 && n <= maxRows ? n : { retry: `Answer a number from 1 to ${maxRows}.` };
+    });
+    status = { ...status, rows: Array.from({ length: count }, (_, i) => rowAt(i) ?? []) };
+    show();
+    for (let i = 0; i < count; i++) {
+        const fallback = rowAt(i);
+        const hint = fallback ? ` [${fallback.join(',')}]` : '';
+        const parts = await askFor(io, `Row ${i + 1}: the parts, comma-separated${hint} `, readParts(fallback, statusline_1.PARTS));
+        status = { ...status, rows: status.rows.map((row, j) => (j === i ? parts : row)) };
+        show();
+    }
+    const segments = await askFor(io, `Cells per bar, ${SEGMENTS.join(' or ')}? [${start.status.segments}] `, (answer) => SEGMENTS.find((n) => String(n) === (answer || String(start.status.segments))) ?? { retry: `Answer ${SEGMENTS.join(' or ')}.` });
+    status = { ...status, segments };
+    show();
+    const theme = await askFor(io, `Theme: ${statusline_1.THEMES.join(', ')}? [${start.status.theme}] `, (answer) => {
+        const name = answer.toLowerCase() || start.status.theme;
+        return statusline_1.THEMES.includes(name) ? name : { retry: `Unknown theme: ${answer}. Answer one of ${statusline_1.THEMES.join(', ')}.` };
+    });
+    status = { ...status, theme };
+    show();
+    status = { ...status, labels: await confirm(io, 'Labels in front of the values, such as ctx and 5h?', start.status.labels) };
+    show();
+    tokenLine = await confirm(io, 'Add the token line, shown when each turn ends?', start.tokenLine);
+    show();
+    let tokenSwitches = start.tokenSwitches;
+    if (tokenLine) {
+        const fallback = tokenPartsOf(start.tokenSwitches);
+        const question = `Token line parts: all, req,out,ctx, or your own list from ${tokenline_1.PARTS.join(', ')}? [${fallback.join(',')}] `;
+        tokenSwitches = tokenSwitchesFor(await askFor(io, question, readTokenParts(fallback)), start.tokenSwitches);
+    }
+    if (!(await confirm(io, 'Write these choices?', true)))
+        return null;
+    return { statusLine: switchesFor(status), tokenLine: tokenLine ? tokenSwitches : null };
+}
+const REPO = 'jv-k/claude-gauge';
+// The end of setup: with gh at hand, offers to star the repo, and stars it
+// only on a yes. Without gh it says nothing. The end of the input is a no.
+async function offerStar(io, { hasGh, star }) {
+    if (!hasGh())
+        return;
+    let yes;
+    try {
+        yes = await confirm(io, `Star ${REPO} on GitHub with gh?`, false);
+    }
+    catch (err) {
+        if (err instanceof EndOfAnswers)
+            return;
+        throw err;
+    }
+    if (!yes)
+        return;
+    io.write(star() ? `Starred ${REPO}. Thank you.\n` : `gh could not star ${REPO}. Nothing else changed.\n`);
+}
+// A status payload to preview with when the status line has saved none:
+// two-fifths of the context, and a 5-hour and a weekly window part used.
+function samplePayload(nowMs) {
+    const at = (ms) => Math.floor((nowMs + ms) / 1000);
+    const hour = 3600 * 1000;
+    return {
+        model: { display_name: 'Opus' },
+        effort: { level: 'high' },
+        workspace: { current_dir: process.cwd() },
+        context_window: { context_window_size: 200000, used_percentage: 43 },
+        rate_limits: {
+            five_hour: { used_percentage: 9, resets_at: at(2 * hour) },
+            seven_day: { used_percentage: 41, resets_at: at(3 * 24 * hour) },
+        },
+        cost: { total_duration_ms: 72 * 60 * 1000 },
+    };
+}
+// The payload the status line saved, or the sample when there is none, or
+// none that reads as a payload: a JSON object that holds something.
+function loadPayload(file, nowMs = Date.now()) {
+    try {
+        const saved = JSON.parse(fs.readFileSync(file, 'utf8'));
+        if (typeof saved === 'object' && saved !== null && !Array.isArray(saved) && Object.keys(saved).length)
+            return saved;
+    }
+    catch {
+        /* no payload saved yet, or half of one */
+    }
+    return samplePayload(nowMs);
+}
+// The preview: the status line's rows for `payload`, with the given switches
+// as words, as the settings command passes them.
+function previewer(payload, options = {}) {
+    return (switches) => (0, statusline_1.render)(payload, { ...options, config: (0, statusline_1.parseArgs)([...switches]) });
+}

package/dist/wordmark.js

@@ -0,0 +1,34 @@
+"use strict";
+// The claude-gauge wordmark, which the CLI prints above its usage and at the
+// start of the setup and configure questions. It is figlet's "future" font,
+// as jv-k/deslopper draws its own, kept here as text so the CLI needs no
+// figlet: three rows of one 3-cell chunk per character of "claude-gauge".
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wordmark = wordmark;
+exports.colorEnabled = colorEnabled;
+const WORDMARK = [
+    ['┏━╸', '╻  ', '┏━┓', '╻ ╻', '╺┳┓', '┏━╸', '   ', '┏━╸', '┏━┓', '╻ ╻', '┏━╸', '┏━╸'],
+    ['┃  ', '┃  ', '┣━┫', '┃ ┃', ' ┃┃', '┣╸ ', '╺━╸', '┃╺┓', '┣━┫', '┃ ┃', '┃╺┓', '┣╸ '],
+    ['┗━╸', '┗━╸', '╹ ╹', '┗━┛', '╺┻┛', '┗━╸', '   ', '┗━┛', '╹ ╹', '┗━┛', '┗━┛', '┗━╸'],
+];
+// A 256-colour number for each chunk: deslopper's rainbow widened to the 11
+// letters, with 27 for blue because 21 reads poorly on a dark background, and
+// grey for the hyphen.
+const COLORS = [196, 202, 208, 214, 226, 118, 244, 82, 39, 27, 93, 163];
+const RESET = '\x1b[0m';
+// Whether to colour what goes to `stream`, in deslopper's order: a non-empty
+// NO_COLOR turns colour off, a FORCE_COLOR or CLICOLOR_FORCE that is neither
+// empty nor 0 turns it on, and otherwise only a terminal gets colour.
+function colorEnabled(stream, env = process.env) {
+    if (env.NO_COLOR)
+        return false;
+    if (['CLICOLOR_FORCE', 'FORCE_COLOR'].some((name) => env[name] && env[name] !== '0'))
+        return true;
+    return stream.isTTY === true;
+}
+// The wordmark's three rows, each ending in a newline. In colour each chunk
+// starts with its colour code and each row ends with a reset.
+function wordmark(color) {
+    const row = (chunks) => color ? chunks.map((chunk, i) => `\x1b[38;5;${COLORS[i]}m${chunk}`).join('') + RESET : chunks.join('');
+    return WORDMARK.map((chunks) => row(chunks) + '\n').join('');
+}

package/package.json

@@ -1,16 +1,38 @@
 {
   "name": "@jv-k/claude-gauge",
-  "version": "0.0.1",
-  "description": "Placeholder. claude-gauge 1.0.0 is a status line and a token line for Claude Code.",
+  "version": "1.1.0",
+  "description": "A status line and a token line for Claude Code: context, 5-hour and weekly usage with pace markers.",
   "license": "MIT",
   "author": "John Valai",
-  "homepage": "https://github.com/jv-k/claude-gauge#readme",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/jv-k/claude-gauge.git"
   },
-  "files": [],
+  "bin": {
+    "claude-gauge": "dist/cli.js",
+    "claude-gauge-statusline": "dist/statusline.js",
+    "claude-gauge-tokenline": "dist/tokenline.js"
+  },
+  "files": [
+    "dist"
+  ],
   "publishConfig": {
     "access": "public"
+  },
+  "packageManager": "pnpm@10.27.0",
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "build": "tsc",
+    "typecheck": "tsc --noEmit",
+    "lint": "biome lint --error-on-warnings",
+    "test": "pnpm build && node scripts/test.js",
+    "bump-release": "verbump --push origin"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "2.5.15",
+    "@types/node": "^18.19.130",
+    "typescript": "^5.9.3"
   }
 }