@ugurcandede/cc-cost 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Ugurcan Dede
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,151 @@
+<div align="center">
+  <img src="docs/assets/logo.svg" alt="cc-cost" width="88">
+  <h1>cc-cost</h1>
+  <p>What your Claude Code usage would cost at API list prices, totalled across all your machines (Windows, Mac, Linux), with an archive that outlives Claude Code's transcript cleanup and a dashboard you open with a double-click.</p>
+  <br>
+  <a href="https://github.com/ugurcandede/cc-cost" target="_blank"><img src="https://img.shields.io/badge/version-0.1.0-blue?style=flat-square" alt="Version 0.1.0"></a>
+  <img src="https://img.shields.io/badge/Node.js-22%2B%20·%20zero%20dependencies-339933?style=flat-square&logo=node.js&logoColor=white" alt="Node.js 22+, zero dependencies">
+  <a href="LICENSE"><img src="https://img.shields.io/badge/license-MIT-blue?style=flat-square" alt="License: MIT"></a>
+  <br>  
+  <img src="https://img.shields.io/badge/Windows-0078D6?style=flat-square&logo=data:image/svg%2Bxml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCAyNCAyNCI+PHBhdGggZmlsbD0id2hpdGUiIGQ9Ik0zIDUuNUwxMCA0LjVWMTEuNUgzVjUuNU0xMSA0LjVMMjEgM1YxMS41SDExVjQuNU0zIDEyLjVIMTBWMTkuNUwzIDE4LjVWMTIuNU0xMSAxMi41SDIxVjIxTDExIDE5LjVWMTIuNVoiLz48L3N2Zz4=" alt="Windows">
+  <img src="https://img.shields.io/badge/macOS-000?style=flat-square&logo=apple&logoColor=white" alt="macOS">
+  <img src="https://img.shields.io/badge/Linux-FCC624?style=flat-square&logo=linux&logoColor=black" alt="Linux">
+</div>
+
+<br>
+<p align="center">
+  <picture>
+    <source media="(prefers-color-scheme: dark)" srcset="docs/assets/dashboard-dark.png">
+    <img src="docs/assets/dashboard-light.png" alt="The cc-cost dashboard: the last 30 days across two machines, daily cost stacked by model" width="800">
+  </picture>
+  <br>
+  <sub>The dashboard, on sample data.</sub>
+</p>
+
+## Quick start
+
+```bash
+npm i -g @ugurcandede/cc-cost          # or, with Yarn 1: yarn global add @ugurcandede/cc-cost
+
+# Pick the folder your machines share (Dropbox, iCloud Drive, OneDrive, …),
+# your language and plan; schedule a daily sync and add the Claude Code hook.
+cc-cost setup
+
+cc-cost                  # sync this machine, print a summary
+cc-cost report --open    # the dashboard
+```
+
+Run `setup` on every machine and point them at the same folder. Each one adds its numbers; every one
+sees the total.
+
+Yarn 2 and later have no global installs: install with npm, or try a report once with
+`yarn dlx @ugurcandede/cc-cost` (or `npx @ugurcandede/cc-cost`). `setup` needs a permanent install,
+since the schedule and hook point at it.
+
+## Prerequisites
+
+- Node.js 22 or newer (no runtime dependencies)
+- Claude Code, which keeps its transcripts in `~/.claude/projects`
+- For several machines: a folder they all sync. Without one, cc-cost counts this machine only
+
+## Everyday commands
+
+```bash
+cc-cost                      # sync, summary, dashboard
+cc-cost daily --last 7       # also weekly, monthly; --breakdown adds per-model rows
+cc-cost projects             # also models, machines, sessions
+cc-cost agents               # main thread vs subagents; also skills, mcp
+cc-cost insights             # context size, cache efficiency, what drives the cost
+cc-cost plan                 # API equivalent vs Pro / Max 5x / Max 20x, rate-limit hits
+cc-cost blocks               # usage in Claude's 5-hour windows
+cc-cost status               # settings, machines, schedule, hook
+```
+
+```
+$ cc-cost projects --last 30
+Project         Calls  Avg context  Cache read  Output       Cost   Share
+─────────────  ──────  ───────────  ──────────  ──────  ─────────  ──────
+api-server      4,728       207.8K      966.9M    5.7M    $722.12   45.6%
+web-app         3,051       237.9K      714.2M    3.4M    $446.28   28.2%
+mobile-app      1,443       214.9K      305.1M    1.7M    $198.60   12.6%
+data-pipeline     533       224.9K      118.0M  500.6K     $90.86    5.7%
+infra             557       231.2K      126.7M  677.1K     $77.03    4.9%
+docs-site         312       265.8K       81.6M  345.3K     $47.20    3.0%
+─────────────  ──────  ───────────  ──────────  ──────  ─────────  ──────
+Total          10,624       221.2K       2.31B   12.3M  $1,582.10  100.0%
+```
+
+Every report takes the same filters and output options:
+
+```bash
+cc-cost daily --since 2026-09-01 --machine macbook --model opus
+cc-cost sessions --project api --limit 10
+cc-cost monthly --json            # or --csv
+cc-cost insights --lang tr        # interface language: en (default) or tr
+```
+
+## How it differs from other tools
+
+- **Several machines, one total**: through a folder you already sync; no server, no account.
+- **History that stays**: numbers are kept after Claude Code deletes old transcripts.
+- **A dashboard in one file**: date, machine, project and model filters, works offline.
+- **Insights, not just totals**: context size per call, cache hit ratio, subagents, skills, MCP servers,
+  the costliest sessions.
+- **Current prices**: read from Anthropic's pricing page daily, with a bundled fallback.
+
+## Layout
+
+What cc-cost keeps in the shared folder:
+
+```
+<shared folder>/
+├── machines/
+│   ├── work-pc.json        # one per machine, written only by that machine
+│   └── macbook.json
+└── dashboard.html          # rewritten on every sync
+```
+
+and on each machine:
+
+```
+~/.config/cc-cost/          # %APPDATA%\cc-cost on Windows
+├── config.json             # cc-cost config
+└── pricing-cache.json      # last prices read from the pricing page
+```
+
+## Safety
+
+- **No conversation content leaves your machine.** Snapshots hold token and call counts per day, project,
+  session and model, plus rate-limit events. Project names can be hashed (`anonymizeProjects`).
+- **The archive only grows.** A day older than Claude Code's cleanup window is never overwritten by a
+  scan that may see only part of it.
+- **No sync conflicts.** Each machine writes only its own file, through write-then-rename.
+- **Your Claude Code settings are backed up** to `settings.json.cc-cost.bak` before the hook is added;
+  other hooks are left alone. `cc-cost setup --remove` takes the schedule and the hook away.
+- Read-only toward transcripts: cc-cost never modifies `~/.claude/projects`.
+
+## Further reading
+
+- [docs/cli.md](docs/cli.md): every command, filter and option
+- [docs/configuration.md](docs/configuration.md): settings, the shared folder, price overrides, privacy
+- [docs/how-it-works.md](docs/how-it-works.md): how costs are calculated, deduplication, the archive,
+  and what cc-cost can't see
+- [docs/maintenance.md](docs/maintenance.md): automatic runs, status, moving from the original script
+
+---
+<p align="center">
+  Built with ❤️ for the Claude Community
+</p>
+
+<p align="center">
+  <a href="https://github.com/ugurcandede">
+    <img src="https://img.shields.io/badge/@ugurcandede-181717?logo=github&logoColor=white" alt="GitHub · @ugurcandede">
+  </a>
+  <a href="https://claude.com/claude-code">
+    <img src="https://img.shields.io/badge/developed%20with-Claude%20Code-D97757?logo=claude&logoColor=white" alt="Developed with Claude Code">
+  </a>
+</p>
+
+<p align="center">
+  <sub>Not affiliated with or endorsed by Anthropic. "Claude" is a trademark of Anthropic, PBC.</sub>
+</p>

package/dist/aggregate.js

@@ -0,0 +1,107 @@
+import { priceFor } from "./pricing.js";
+import { T, T_LEN } from "./types.js";
+export const modelLabel = (r) => (r.f ? `${r.m}-fast` : r.m);
+export const agentOf = (r) => r.a ?? 'main';
+const n = (t, i) => t[i] ?? 0;
+export function costOf(t, p, webSearch) {
+    return [
+        (n(t, T.input) * p[0]) / 1e6,
+        (n(t, T.write5m) * p[1] + n(t, T.write1h) * p[2]) / 1e6,
+        (n(t, T.read) * p[3]) / 1e6,
+        (n(t, T.output) * p[4]) / 1e6,
+        n(t, T.webSearch) * webSearch,
+    ];
+}
+const sum = (c) => c[0] + c[1] + c[2] + c[3] + c[4];
+export function priceRows(snaps, table, overrides = {}) {
+    const rows = [];
+    const hours = [];
+    const limits = [];
+    const unknown = new Set();
+    for (const snap of snaps) {
+        for (const r of snap.rows) {
+            const p = priceFor(table, r.m, !!r.f, overrides);
+            if (!p) {
+                unknown.add(modelLabel(r));
+                continue;
+            }
+            const c = costOf(r.t, p, table.webSearch);
+            rows.push({ ...r, machine: snap.machine, c, cost: sum(c) });
+        }
+        for (const h of snap.hourly) {
+            const p = priceFor(table, h.m, !!h.f, overrides);
+            if (p)
+                hours.push({ ...h, machine: snap.machine, cost: sum(costOf(h.t, p, table.webSearch)) });
+        }
+        for (const l of snap.limits)
+            limits.push({ ...l, machine: snap.machine });
+    }
+    return { rows, hours, limits, unknown };
+}
+// What the same tokens would cost on another model at standard speed
+export function repriceAs(rows, table, model) {
+    const p = table.models[model];
+    return p && rows.reduce((acc, r) => acc + sum(costOf(r.t, p, table.webSearch)), 0);
+}
+// Name filters match case-insensitive substrings ("opus" -> every Opus model); sessions match by id prefix.
+const matches = (wanted, value) => !wanted?.length || wanted.some((w) => value.toLowerCase().includes(w.toLowerCase()));
+export function applyFilter(rows, f) {
+    return rows.filter((r) => (!f.since || r.d >= f.since) &&
+        (!f.until || r.d <= f.until) &&
+        matches(f.machine, r.machine) &&
+        matches(f.project, r.p) &&
+        matches(f.model, modelLabel(r)) &&
+        (!f.session?.length || f.session.some((s) => r.s.startsWith(s))) &&
+        matches(f.agent, agentOf(r)) &&
+        matches(f.skill, r.k ?? '') &&
+        matches(f.mcp, r.x ?? ''));
+}
+// Hourly data has no project, session or attribution; only these filters apply to it.
+export const hourFilterable = (f) => !f.project?.length && !f.session?.length && !f.agent?.length && !f.skill?.length && !f.mcp?.length;
+export function applyHourFilter(hours, f) {
+    return hours.filter((h) => (!f.since || h.d >= f.since) && (!f.until || h.d <= f.until) && matches(f.machine, h.machine) && matches(f.model, modelLabel(h)));
+}
+const emptyTotals = () => ({
+    cost: 0, c: [0, 0, 0, 0, 0], t: new Array(T_LEN).fill(0), sessions: new Set(), days: new Set(), machines: new Set(),
+});
+function add(acc, r) {
+    acc.cost += r.cost;
+    for (let i = 0; i < 5; i++)
+        acc.c[i] += r.c[i];
+    for (let i = 0; i < T_LEN; i++)
+        acc.t[i] = i === T.maxContext ? Math.max(acc.t[i], n(r.t, i)) : acc.t[i] + n(r.t, i);
+    acc.sessions.add(r.s);
+    acc.days.add(r.d);
+    acc.machines.add(r.machine);
+}
+export function totals(rows) {
+    const acc = emptyTotals();
+    for (const r of rows)
+        add(acc, r);
+    return acc;
+}
+export function groupBy(rows, key) {
+    const out = new Map();
+    for (const r of rows) {
+        const k = key(r);
+        let acc = out.get(k);
+        if (!acc)
+            out.set(k, (acc = emptyTotals()));
+        add(acc, r);
+    }
+    return out;
+}
+export const byCost = (m) => [...m].sort((a, b) => b[1].cost - a[1].cost);
+// Monday of the ISO week containing the date
+export function weekOf(date) {
+    const t = new Date(date + 'T00:00:00Z');
+    t.setUTCDate(t.getUTCDate() - ((t.getUTCDay() + 6) % 7));
+    return t.toISOString().slice(0, 10);
+}
+export const contextTokens = (t) => n(t, T.input) + n(t, T.write5m) + n(t, T.write1h) + n(t, T.read);
+// Mean context per call: every call re-reads its whole prompt, which is what drives cache-read cost.
+export const avgContext = (t) => (n(t, T.calls) ? contextTokens(t) / n(t, T.calls) : 0);
+// Share of prompt tokens served from cache
+export const cacheHitRatio = (t) => (contextTokens(t) ? n(t, T.read) / contextTokens(t) : 0);
+// Calendar days from `from` to `to`, inclusive
+export const daysBetween = (from, to) => Math.round((Date.parse(to) - Date.parse(from)) / 864e5) + 1;

package/dist/cli.js

@@ -0,0 +1,351 @@
+#!/usr/bin/env node
+import { spawn } from 'node:child_process';
+import fs from 'node:fs';
+import { createRequire } from 'node:module';
+import path from 'node:path';
+import readline from 'node:readline/promises';
+import { parseArgs } from 'node:util';
+import { applyFilter, applyHourFilter, hourFilterable, priceRows } from "./aggregate.js";
+import { CONFIG_KEYS, configFile, loadConfig, PLANS, saveConfig } from "./config.js";
+import { writeDashboard } from "./dashboard.js";
+import { paint, setColor, table } from "./format.js";
+import { fill, L, lang, LANGS, setLang } from "./i18n.js";
+import { claudeDirs, configDir, defaultMachine, retentionDays } from "./paths.js";
+import { loadPrices } from "./pricing.js";
+import { blocksReport, dimensionJson, dimensionReport, DIMENSIONS, insights, limitsInRange, periodJson, periodReport, PERIODS, planReport, renderCsv, renderTable, summary, summaryJson, } from "./reports.js";
+import { localClock } from "./scan.js";
+import { claudeSettingsFile, currentRunner, dataFolderIn, hookInstalled, installHook, installSchedule, isEphemeral, removeHook, removeSchedule, SCHEDULE_TIME, scheduleInstalled, syncFolders, } from "./setup.js";
+import { loadAll } from "./snapshot.js";
+import { dashboardPath, sync } from "./sync.js";
+// Name, version and project page come from package.json only
+const pkg = createRequire(import.meta.url)('../package.json');
+const REPO = pkg.homepage.replace(/#.*$/, '');
+const NPM = `https://www.npmjs.com/package/${pkg.name}`;
+const { values: opt, positionals } = parseArgs({
+    allowPositionals: true,
+    options: {
+        since: { type: 'string' },
+        until: { type: 'string' },
+        last: { type: 'string' },
+        machine: { type: 'string', multiple: true },
+        project: { type: 'string', multiple: true },
+        model: { type: 'string', multiple: true },
+        session: { type: 'string', multiple: true },
+        agent: { type: 'string', multiple: true },
+        skill: { type: 'string', multiple: true },
+        mcp: { type: 'string', multiple: true },
+        json: { type: 'boolean' },
+        csv: { type: 'boolean' },
+        breakdown: { type: 'boolean' },
+        limit: { type: 'string' },
+        lang: { type: 'string' },
+        tz: { type: 'string' },
+        'no-color': { type: 'boolean' },
+        'no-sync': { type: 'boolean' },
+        offline: { type: 'boolean' },
+        quiet: { type: 'boolean' },
+        open: { type: 'boolean' },
+        refresh: { type: 'boolean' },
+        'sync-dir': { type: 'string' },
+        yes: { type: 'boolean', short: 'y' },
+        'no-schedule': { type: 'boolean' },
+        'no-hook': { type: 'boolean' },
+        remove: { type: 'boolean' },
+        help: { type: 'boolean', short: 'h' },
+        version: { type: 'boolean', short: 'v' },
+    },
+});
+let config = loadConfig();
+const resolveSettings = () => ({
+    syncDir: path.resolve(opt['sync-dir'] ?? process.env.CC_COST_DIR ?? config.syncDir ?? path.join(configDir(), 'data')),
+    machine: config.machine ?? defaultMachine(),
+    lang: opt.lang ?? config.lang ?? 'en',
+    timezone: opt.tz ?? config.timezone ?? Intl.DateTimeFormat().resolvedOptions().timeZone,
+    planPrice: PLANS[config.plan ?? 'max5x'] ?? 100,
+    anonymize: !!config.anonymizeProjects,
+    pricing: config.pricing ?? {},
+});
+let settings = resolveSettings();
+setLang(settings.lang);
+setColor(!opt['no-color']);
+const out = (text) => {
+    if (!opt.quiet)
+        console.log(text);
+};
+function fail(message) {
+    console.error(message);
+    process.exit(1);
+}
+const list = (v) => v?.flatMap((s) => s.split(',')).map((s) => s.trim()).filter(Boolean);
+function date(flag, v) {
+    if (v !== undefined && !/^\d{4}-\d{2}-\d{2}$/.test(v))
+        fail(fill(L().badDate, { flag, value: v }));
+    return v;
+}
+function count(flag, v) {
+    if (v === undefined)
+        return undefined;
+    const n = Number(v);
+    if (!Number.isInteger(n) || n < 1)
+        fail(fill(L().badNumber, { flag, value: v }));
+    return n;
+}
+const localDay = (daysAgo) => localClock(settings.timezone)(new Date(Date.now() - daysAgo * 864e5).toISOString()).d;
+function filter() {
+    const last = count('--last', opt.last);
+    return {
+        since: last ? localDay(last - 1) : date('--since', opt.since),
+        until: date('--until', opt.until),
+        machine: list(opt.machine),
+        project: list(opt.project),
+        model: list(opt.model),
+        session: list(opt.session),
+        agent: list(opt.agent),
+        skill: list(opt.skill),
+        mcp: list(opt.mcp),
+    };
+}
+function openFile(file) {
+    const [cmd, args] = process.platform === 'win32' ? ['cmd', ['/c', 'start', '""', file]]
+        : process.platform === 'darwin' ? ['open', [file]]
+            : ['xdg-open', [file]];
+    spawn(cmd, args, { detached: true, stdio: 'ignore' }).unref();
+}
+const pricesCache = () => path.join(configDir(), 'pricing-cache.json');
+async function data(verbose) {
+    if (!opt['no-sync']) {
+        const r = await sync(settings);
+        if (verbose) {
+            out(fill(L().scanned, { machine: settings.machine, files: r.scan.files, dupes: r.scan.duplicates }));
+            out(fill(L().snapshot, { file: r.file }) + (r.kept ? fill(L().kept, { n: r.kept }) : ''));
+        }
+    }
+    const prices = await loadPrices(pricesCache(), { offline: opt.offline });
+    const snaps = loadAll(settings.syncDir);
+    return { ...priceRows(snaps, prices.table, settings.pricing), prices, snaps };
+}
+function dashboard(d) {
+    const dates = d.rows.map((r) => r.d).sort();
+    const t = d.prices.table;
+    return writeDashboard(d, {
+        lang: settings.lang,
+        timezone: settings.timezone,
+        planPrice: settings.planPrice,
+        updated: new Date().toISOString(),
+        machines: d.snaps.length,
+        first: dates[0] ?? '',
+        last: dates[dates.length - 1] ?? '',
+        prices: `${t.source === 'bundled' ? 'bundled' : 'platform.claude.com'} ${t.date.slice(0, 10)}`,
+        version: pkg.version,
+        repo: REPO,
+        npm: NPM,
+        site: pkg.author.url,
+    }, dashboardPath(settings));
+}
+function footer(d) {
+    if (d.prices.note)
+        out(fill(L().pricesFallback, { reason: d.prices.note, source: d.prices.table.source, date: d.prices.table.date.slice(0, 10) }));
+    if (d.unknown.size)
+        out(fill(L().unknownModels, { list: [...d.unknown].join(', ') }));
+}
+// Print a table report as a table, CSV or JSON
+function emit(report, json, empty) {
+    if (opt.json)
+        return out(JSON.stringify(json, null, 2));
+    if (opt.csv)
+        return out(renderCsv(report));
+    out(empty ? L().noData : renderTable(report));
+}
+const machineMatch = (f) => (m) => !f.machine?.length || f.machine.some((w) => m.toLowerCase().includes(w.toLowerCase()));
+async function ask(rl, question) {
+    return rl ? (await rl.question(question)).trim() : '';
+}
+const yes = (answer) => answer === '' || /^[yeYE]/.test(answer);
+async function setup() {
+    const S = L().setup;
+    const runner = currentRunner();
+    if (opt.remove) {
+        const removed = [removeSchedule(), removeHook() ? claudeSettingsFile() : undefined].filter(Boolean);
+        return out(removed.length ? removed.map((w) => fill(S.removed, { what: w })).join('\n') : S.nothingToRemove);
+    }
+    const interactive = !opt.yes && process.stdin.isTTY;
+    const rl = interactive ? readline.createInterface({ input: process.stdin, output: process.stdout }) : undefined;
+    try {
+        out(paint('bold', fill(S.title, { version: pkg.version })));
+        const next = { ...config };
+        if (opt['sync-dir'])
+            next.syncDir = path.resolve(opt['sync-dir']);
+        else {
+            const folders = syncFolders();
+            const proposal = next.syncDir ?? (folders[0] && dataFolderIn(folders[0]));
+            if (folders.length)
+                out(fill(S.found, { list: folders.join(', ') }));
+            let chosen = proposal && yes(await ask(rl, fill(S.usePath, { path: proposal }))) ? proposal : undefined;
+            if (!chosen && rl)
+                chosen = (await ask(rl, S.askPath)) || undefined;
+            if (chosen)
+                next.syncDir = path.resolve(chosen);
+            else
+                out(S.localOnly);
+        }
+        const langAnswer = opt.lang ?? (await ask(rl, fill(S.lang, { current: next.lang ?? 'en' })));
+        if (langAnswer && LANGS[langAnswer])
+            next.lang = langAnswer;
+        const planAnswer = await ask(rl, fill(S.plan, { current: next.plan ?? 'max5x' }));
+        if (planAnswer && PLANS[planAnswer])
+            next.plan = planAnswer;
+        next.plan ??= 'max5x';
+        saveConfig(next);
+        config = next;
+        settings = resolveSettings();
+        setLang(settings.lang);
+        out(fill(L().setup.saved, { file: configFile() }));
+        const wantSchedule = !opt['no-schedule'] && yes(await ask(rl, fill(S.schedule, { time: SCHEDULE_TIME })));
+        const wantHook = !opt['no-hook'] && yes(await ask(rl, fill(S.hook, { file: claudeSettingsFile() })));
+        if ((wantSchedule || wantHook) && isEphemeral(runner))
+            out(S.npx);
+        else {
+            if (wantSchedule) {
+                const r = installSchedule(runner);
+                out(fill(r.ok ? S.scheduled : S.scheduleFailed, r.ok ? { what: r.what } : { reason: r.what }));
+            }
+            if (wantHook)
+                out(fill(installHook(runner) ? S.hookAdded : S.hookKept, { file: claudeSettingsFile() }));
+        }
+    }
+    finally {
+        rl?.close();
+    }
+    out('\n' + S.firstSync);
+    const d = await data(true);
+    out(fill(L().dashboard, { file: dashboard(d) }));
+}
+async function status() {
+    const St = L().status;
+    const snaps = loadAll(settings.syncDir);
+    const prices = await loadPrices(pricesCache(), { offline: true });
+    const info = {
+        version: pkg.version,
+        config: configFile(),
+        syncDir: settings.syncDir,
+        machine: settings.machine,
+        machines: snaps.map((s) => ({ name: s.machine, updated: s.updated, days: new Set(s.rows.map((r) => r.d)).size })),
+        retentionDays: retentionDays(claudeDirs()),
+        schedule: scheduleInstalled(),
+        hook: hookInstalled(),
+        prices: { source: prices.table.source, date: prices.table.date },
+    };
+    if (opt.json)
+        return out(JSON.stringify(info, null, 2));
+    const when = (iso) => (iso ? new Date(iso).toLocaleString(lang() === 'tr' ? 'tr-TR' : 'en-US', { timeZone: settings.timezone }) : '–');
+    const pairs = [
+        [St.version, info.version],
+        [St.config, info.config + (fs.existsSync(info.config) ? '' : ' (–)')],
+        [St.syncDir, info.syncDir],
+        [St.machine, info.machine],
+        [St.machines, info.machines.length ? info.machines.map((m) => fill(St.machineLine, { name: m.name, updated: when(m.updated), days: m.days })).join('\n' + ' '.repeat(0)) : St.none],
+        [St.retention, fill(St.retentionValue, { n: info.retentionDays })],
+        [St.scheduler, info.schedule ? St.yes : St.no],
+        [St.hook, info.hook ? St.yes : St.no],
+        [St.prices, `${info.prices.source}, ${info.prices.date.slice(0, 10)}`],
+    ];
+    const w = Math.max(...pairs.map(([k]) => k.length));
+    for (const [k, v] of pairs)
+        out(paint('dim', k.padEnd(w)) + '  ' + v.split('\n').join('\n' + ' '.repeat(w + 2)));
+}
+async function main() {
+    if (opt.help)
+        return out(fill(L().help, { version: pkg.version, url: REPO }));
+    if (opt.version)
+        return out(pkg.version);
+    const [cmd = '', ...rest] = positionals;
+    const tableCommands = [...PERIODS, ...DIMENSIONS, 'plan', 'blocks'];
+    if (opt.csv && !tableCommands.includes(cmd))
+        fail(L().csvUnsupported);
+    if (cmd === '' || cmd === 'sync') {
+        const d = await data(cmd === '');
+        const file = dashboard(d);
+        if (cmd === 'sync')
+            return;
+        const rows = applyFilter(d.rows, filter());
+        if (opt.json)
+            return out(JSON.stringify(summaryJson(rows), null, 2));
+        out('\n' + (rows.length ? summary(rows) : L().noData));
+        out('\n' + fill(L().dashboard, { file }));
+        return footer(d);
+    }
+    if (PERIODS.includes(cmd) || DIMENSIONS.includes(cmd) || ['insights', 'plan', 'blocks'].includes(cmd)) {
+        const d = await data(false);
+        const f = filter();
+        const rows = applyFilter(d.rows, f);
+        const limits = limitsInRange(d.limits, settings.timezone, f.since, f.until, machineMatch(f));
+        const limit = count('--limit', opt.limit) ?? (['sessions', 'projects', 'blocks'].includes(cmd) ? 20 : undefined);
+        if (PERIODS.includes(cmd)) {
+            const p = cmd;
+            emit(periodReport(rows, p, { breakdown: opt.breakdown, flat: opt.csv }), periodJson(rows, p, opt.breakdown), !rows.length);
+        }
+        else if (DIMENSIONS.includes(cmd)) {
+            const dim = cmd;
+            emit(dimensionReport(rows, dim, limit), dimensionJson(rows, dim, limit), !rows.length);
+        }
+        else if (cmd === 'plan') {
+            const p = planReport(rows, limits, { timezone: settings.timezone, plan: config.plan });
+            emit(p.report, p.json, !rows.length);
+            if (!opt.json && !opt.csv && rows.length)
+                out('\n' + p.notes.join('\n'));
+        }
+        else if (cmd === 'blocks') {
+            if (!hourFilterable(f))
+                console.error(L().hourFilters);
+            const hours = applyHourFilter(d.hours, f);
+            const report = blocksReport(hours, limits, { timezone: settings.timezone, limit });
+            emit(report, report.rows.map((r) => Object.fromEntries(report.cols.map((c, i) => [c.title, r[i]]))), !hours.length);
+        }
+        else {
+            const hours = hourFilterable(f) ? applyHourFilter(d.hours, f) : undefined;
+            const r = insights({ rows, hours, limits, table: d.prices.table, timezone: settings.timezone });
+            out(opt.json ? JSON.stringify(r.json, null, 2) : rows.length ? r.text : L().noData);
+        }
+        if (!opt.json && !opt.csv)
+            footer(d);
+        return;
+    }
+    if (cmd === 'report') {
+        const file = dashboard(await data(false));
+        out(fill(L().dashboard, { file }));
+        if (opt.open)
+            openFile(file);
+        return;
+    }
+    if (cmd === 'pricing') {
+        const { table: t, note } = await loadPrices(pricesCache(), { offline: opt.offline, refresh: opt.refresh });
+        if (opt.json)
+            return out(JSON.stringify(t, null, 2));
+        const c = L().col;
+        const models = Object.entries(t.models).map(([m, p]) => [m, p.join(' / ')]);
+        const fast = Object.entries(t.fast).map(([m, p]) => [m + '-fast', p.map((v) => +v.toFixed(4)).join(' / ')]);
+        out(table([c.model, c.price], [...models, ...fast], { left: [1] }));
+        const date = t.date.slice(0, 10);
+        out('\n' + (note ? fill(L().pricesFallback, { reason: note, source: t.source, date }) : fill(L().pricesLive, { source: t.source, date })));
+        return;
+    }
+    if (cmd === 'setup')
+        return setup();
+    if (cmd === 'status')
+        return status();
+    if (cmd === 'config') {
+        if (rest[0] === 'set') {
+            const [key, value = ''] = rest.slice(1);
+            if (!CONFIG_KEYS.includes(key))
+                fail(fill(L().configUnknownKey, { key: String(key), keys: CONFIG_KEYS.join(', ') }));
+            const next = { ...config };
+            next[key] = key === 'anonymizeProjects' ? value === 'true' : key === 'syncDir' ? path.resolve(value) : value;
+            saveConfig(next);
+            return out(fill(L().configSet, { key: key, value: String(next[key]) }));
+        }
+        out(fill(L().configFile, { file: configFile() }));
+        return out(JSON.stringify({ ...settings, languages: Object.keys(LANGS) }, null, 2));
+    }
+    fail(fill(L().unknownCommand, { cmd }));
+}
+await main();

package/dist/config.js

@@ -0,0 +1,15 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { configDir } from "./paths.js";
+// Monthly subscription price in USD
+export const PLANS = { pro: 20, max5x: 100, max20x: 200 };
+export const CONFIG_KEYS = ['syncDir', 'machine', 'lang', 'timezone', 'plan', 'anonymizeProjects'];
+export const configFile = () => path.join(configDir(), 'config.json');
+export function loadConfig() {
+    const file = configFile();
+    return fs.existsSync(file) ? JSON.parse(fs.readFileSync(file, 'utf8')) : {};
+}
+export function saveConfig(config) {
+    fs.mkdirSync(configDir(), { recursive: true });
+    fs.writeFileSync(configFile(), JSON.stringify(config, null, 2) + '\n');
+}