savemytokens 0.2.0

package/dist/analyze/score.js

@@ -0,0 +1,20 @@
+const MAX_WASTE_PENALTY = 55;
+const MAX_ERROR_PENALTY = 8;
+const MAX_INTERRUPT_PENALTY = 5;
+export function scoreAudit(agg, wasteRatio) {
+    const breakdown = [{ id: "base", label: "Base", points: 100 }];
+    const wastePenalty = Math.min(MAX_WASTE_PENALTY, Math.round(wasteRatio * 120));
+    if (wastePenalty > 0)
+        breakdown.push({ id: "waste", label: "Avoidable token spend", points: -wastePenalty });
+    const turns = Math.max(1, agg.totals.turns);
+    const errorRate = (agg.apiErrors + agg.toolErrors) / turns;
+    const errorPenalty = Math.min(MAX_ERROR_PENALTY, Math.round(errorRate * 40));
+    if (errorPenalty > 0)
+        breakdown.push({ id: "errors", label: "Failed calls and retries", points: -errorPenalty });
+    const tasks = Math.max(1, agg.totals.tasks);
+    const interruptPenalty = Math.min(MAX_INTERRUPT_PENALTY, Math.round((agg.outcomes.interrupted / tasks) * 20));
+    if (interruptPenalty > 0)
+        breakdown.push({ id: "interrupted", label: "Interrupted tasks", points: -interruptPenalty });
+    const total = breakdown.reduce((sum, c) => sum + c.points, 0);
+    return { score: Math.max(0, Math.min(100, Math.round(total))), breakdown };
+}

package/dist/cli-options.js

@@ -0,0 +1,149 @@
+const COMMANDS = new Set([
+    "control",
+    "status",
+    "share",
+    "priority",
+    "release",
+    "pin",
+    "park",
+    "policy",
+    "defer",
+    "hud",
+    "audit",
+    "install",
+    "uninstall",
+    "watch",
+    "history",
+    "privacy",
+    "theme",
+    "help",
+]);
+export function parseArgs(argv) {
+    const options = {
+        command: "control",
+        args: [],
+        days: 7,
+        project: null,
+        projectExplicit: false,
+        json: false,
+        verbose: false,
+        save: true,
+        interval: 60,
+        dryRun: false,
+        force: false,
+        window: "five_hour",
+        adapter: "claude-code",
+        rules: false,
+        purge: false,
+        help: false,
+        version: false,
+    };
+    let commandSeen = false;
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
+        if (arg === undefined)
+            continue;
+        if (!arg.startsWith("-")) {
+            if (!commandSeen && COMMANDS.has(arg)) {
+                options.command = arg;
+                commandSeen = true;
+            }
+            else if (!commandSeen && options.args.length === 0) {
+                options.command = "unknown";
+                options.args.push(arg);
+                commandSeen = true;
+            }
+            else {
+                options.args.push(arg);
+            }
+            continue;
+        }
+        switch (arg) {
+            case "--days":
+            case "-d": {
+                const value = Number(argv[++i]);
+                if (Number.isFinite(value) && value > 0)
+                    options.days = Math.min(365, Math.round(value));
+                break;
+            }
+            case "--here":
+                options.project = process.cwd();
+                options.projectExplicit = true;
+                break;
+            case "--project": {
+                const value = argv[++i];
+                if (value) {
+                    options.project = value;
+                    options.projectExplicit = true;
+                }
+                break;
+            }
+            case "--all":
+                options.project = null;
+                options.projectExplicit = true;
+                break;
+            case "--json":
+                options.json = true;
+                break;
+            case "--verbose":
+            case "-v":
+                options.verbose = true;
+                break;
+            case "--no-save":
+                options.save = false;
+                break;
+            case "--dry-run":
+                options.dryRun = true;
+                break;
+            case "--force":
+                options.force = true;
+                break;
+            case "--window": {
+                const value = String(argv[++i] ?? "");
+                if (/^(7d|week|seven|seven_day)$/i.test(value))
+                    options.window = "seven_day";
+                else
+                    options.window = "five_hour";
+                break;
+            }
+            case "--7d":
+                options.window = "seven_day";
+                break;
+            case "--adapter": {
+                const value = argv[++i];
+                if (value)
+                    options.adapter = value;
+                break;
+            }
+            case "--codex":
+                options.adapter = "codex";
+                break;
+            case "--claude":
+            case "--claude-code":
+                options.adapter = "claude-code";
+                break;
+            case "--rules":
+                options.rules = true;
+                break;
+            case "--purge":
+                options.purge = true;
+                break;
+            case "--interval": {
+                const value = Number(argv[++i]);
+                if (Number.isFinite(value) && value >= 5)
+                    options.interval = Math.round(value);
+                break;
+            }
+            case "--help":
+            case "-h":
+                options.help = true;
+                break;
+            case "--version":
+                options.version = true;
+                break;
+            default:
+                break;
+        }
+    }
+    return options;
+}

package/dist/cli.js

@@ -0,0 +1,141 @@
+#!/usr/bin/env node
+import fs from "node:fs";
+import { parseArgs } from "./cli-options.js";
+import { runAudit } from "./commands/audit.js";
+import { runControl } from "./commands/control.js";
+import { runInstall, runUninstall } from "./commands/install.js";
+import { runHud } from "./commands/hud.js";
+import { runDefer, runPolicy } from "./commands/policy.js";
+import { runPrivacy } from "./commands/privacy.js";
+import { runSet } from "./commands/set.js";
+import { runTheme } from "./commands/theme.js";
+import { runWatch } from "./commands/watch.js";
+import { renderHistory } from "./report/render.js";
+import { loadRuns } from "./storage/store.js";
+import { bold, dim } from "./util/ansi.js";
+function version() {
+    try {
+        const pkg = JSON.parse(fs.readFileSync(new URL("../package.json", import.meta.url), "utf8"));
+        return String(pkg.version ?? "0.0.0");
+    }
+    catch {
+        return "0.0.0";
+    }
+}
+function help() {
+    return `
+${bold("savemytokens")}: give every Claude Code session a target share of your Claude window.
+
+  npx savemytokens             the control centre
+  npx savemytokens install     hooks + status line, so it works while the TUI is closed
+  npx savemytokens uninstall   remove them
+  npx savemytokens status      one plain-text snapshot
+  npx savemytokens share <project> <percent|auto>
+  npx savemytokens priority <project> <high|normal|low>
+  npx savemytokens release <project>          hand its unused share back
+  npx savemytokens pin|park <project>         keep it visible, or drop it from the set
+  npx savemytokens policy      what Claude does as the window fills
+  npx savemytokens defer       work pushed to the next session
+  npx savemytokens hud         status line layouts, previewed on your numbers
+  npx savemytokens theme       themes for the TUI and the status line
+  npx savemytokens audit       the token-waste report
+  npx savemytokens watch       keep watching, and report drift as it happens
+  npx savemytokens history     past audit scores
+  npx savemytokens privacy     every file it reads and writes
+
+  -d, --days <n>   audit window (default 7)
+      --json       machine-readable
+      --force      install: wrap an existing status line instead of leaving it alone
+      --rules      install: also write the token-discipline block into ~/.claude/CLAUDE.md
+      --purge      uninstall: also delete ~/.savemytokens
+      --7d         allocate against the weekly window instead of the 5-hour one
+      --codex      Codex instead of Claude Code (visibility only)
+
+${dim("Everything runs locally. No account, no daemon, no upload. See what it stores: savemytokens privacy")}
+${dim("Questions, bugs and ideas: hello@offbeatport.com")}
+`;
+}
+const KNOWN_COMMANDS = [
+    "audit",
+    "defer",
+    "help",
+    "history",
+    "hud",
+    "install",
+    "park",
+    "pin",
+    "policy",
+    "priority",
+    "privacy",
+    "release",
+    "share",
+    "status",
+    "theme",
+    "uninstall",
+    "watch",
+];
+async function main() {
+    const options = parseArgs(process.argv.slice(2));
+    if (options.version) {
+        process.stdout.write(`${version()}\n`);
+        return;
+    }
+    if (options.help || options.command === "help") {
+        process.stdout.write(help());
+        return;
+    }
+    switch (options.command) {
+        case "install":
+            runInstall({ dryRun: options.dryRun, force: options.force, rules: options.rules });
+            return;
+        case "uninstall":
+            runUninstall(options.purge);
+            return;
+        case "theme":
+            runTheme(options.args);
+            return;
+        case "hud":
+            runHud(options);
+            return;
+        case "share":
+        case "priority":
+        case "release":
+        case "pin":
+        case "park":
+            runSet(options);
+            return;
+        case "policy":
+            runPolicy(options);
+            return;
+        case "defer":
+            runDefer(options);
+            return;
+        case "audit":
+            await runAudit(options);
+            return;
+        case "watch":
+            await runWatch(options);
+            return;
+        case "history":
+            process.stdout.write(renderHistory(loadRuns()));
+            return;
+        case "privacy":
+            runPrivacy();
+            return;
+        case "unknown": {
+            const name = options.args[0] ?? "";
+            const known = [...KNOWN_COMMANDS].filter((command) => command.startsWith(name[0] ?? "")).slice(0, 4);
+            process.stderr.write(`savemytokens: no command called ${name}.\n` +
+                (known.length > 0 ? `Did you mean: ${known.join(", ")}?\n` : "") +
+                "Run savemytokens --help for the list.\n");
+            process.exitCode = 1;
+            return;
+        }
+        default:
+            await runControl(options);
+    }
+}
+main().catch((error) => {
+    process.stderr.write(`savemytokens: ${error.message}\n`);
+    process.exitCode = 1;
+});

package/dist/collect.js

@@ -0,0 +1,62 @@
+import { activeAdapters } from "./adapters/index.js";
+import { EvidenceCache } from "./storage/cache.js";
+async function pool(items, limit, worker) {
+    let cursor = 0;
+    const runners = Array.from({ length: Math.min(limit, items.length) }, async () => {
+        for (;;) {
+            const index = cursor++;
+            if (index >= items.length)
+                return;
+            const item = items[index];
+            if (item === undefined)
+                return;
+            await worker(item, index);
+        }
+    });
+    await Promise.all(runners);
+}
+export async function collect(options) {
+    const now = Date.now();
+    const since = now - options.days * 24 * 60 * 60 * 1000;
+    const sessions = [];
+    const adapters = activeAdapters();
+    const refs = [];
+    for (const adapter of adapters) {
+        const cache = new EvidenceCache(adapter.id);
+        for (const ref of adapter.discover({ since, project: options.project })) {
+            refs.push({ ref, cache });
+        }
+    }
+    let done = 0;
+    await pool(refs, options.concurrency ?? 8, async ({ ref, cache }) => {
+        const cached = cache.get(ref.file, ref.size, ref.mtimeMs);
+        if (cached) {
+            sessions.push(cached);
+        }
+        else {
+            const adapter = adapters.find((a) => a.id === ref.adapter);
+            const evidence = adapter ? await adapter.parse(ref) : null;
+            if (evidence) {
+                cache.set(evidence);
+                sessions.push(evidence);
+            }
+        }
+        done++;
+        options.onProgress?.(done, refs.length);
+    });
+    const caches = new Set(refs.map((r) => r.cache));
+    for (const cache of caches)
+        cache.flush();
+    sessions.sort((a, b) => a.startedAt - b.startedAt);
+    return {
+        scope: {
+            adapters: adapters.map((a) => a.id),
+            days: options.days,
+            project: options.project,
+            sessions: sessions.length,
+            from: since,
+            to: now,
+        },
+        sessions,
+    };
+}

package/dist/commands/audit.js

@@ -0,0 +1,74 @@
+import fs from "node:fs";
+import path from "node:path";
+import { activeAdapters, pendingDetected } from "../adapters/index.js";
+import { encodeProject } from "../adapters/claude-code/index.js";
+import { analyze } from "../analyze/index.js";
+import { collect } from "../collect.js";
+import { renderAudit } from "../report/render.js";
+import { loadRuns, previousRun, saveRun } from "../storage/store.js";
+import { dim } from "../util/ansi.js";
+import { hookInstalled, nudgeStats } from "./install.js";
+function progress(done, total) {
+    if (!process.stderr.isTTY || total < 12)
+        return;
+    const pct = Math.round((done / total) * 100);
+    process.stderr.write(`\r${dim(`reading sessions ${pct}%`)}`);
+    if (done === total)
+        process.stderr.write("\r" + " ".repeat(24) + "\r");
+}
+function hasLocalData(cwd) {
+    for (const adapter of activeAdapters()) {
+        if (adapter.id !== "claude-code")
+            continue;
+        try {
+            if (fs.existsSync(path.join(adapter.dataDir, encodeProject(cwd))))
+                return true;
+        }
+        catch {
+            continue;
+        }
+    }
+    return false;
+}
+export function defaultProject(options) {
+    if (options.projectExplicit)
+        return options.project;
+    const cwd = process.cwd();
+    return hasLocalData(cwd) ? cwd : null;
+}
+export async function runAudit(options) {
+    if (activeAdapters().length === 0) {
+        process.stdout.write("\nNo Claude Code or Codex data found.\nRun one of them once, then try again.\n\n");
+        return null;
+    }
+    const project = defaultProject(options);
+    const corpus = await collect({
+        days: options.days,
+        project,
+        onProgress: options.json ? undefined : progress,
+    });
+    const audit = analyze(corpus);
+    const runs = loadRuns();
+    const previous = previousRun(audit, runs);
+    if (options.json) {
+        process.stdout.write(JSON.stringify({ audit, previous }, null, 2) + "\n");
+    }
+    else {
+        process.stdout.write(renderAudit({
+            audit,
+            previous,
+            history: runs,
+            nudges: nudgeStats(),
+            installed: hookInstalled(),
+            verbose: options.verbose,
+        }));
+        if (options.verbose) {
+            for (const pending of pendingDetected()) {
+                process.stdout.write(dim(`${pending.label} found, but skipped: ${pending.reason}.\n`));
+            }
+        }
+    }
+    if (options.save)
+        saveRun(audit);
+    return audit;
+}