tonik 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Takahiro Inaba
+
+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,68 @@
+# tonik
+
+**Score and tune how you use AI — right in your terminal.**
+
+`tonik` reads your local Claude Code session logs and shows a beautiful dashboard
+of how efficiently you're using AI: token spend, cost, cache efficiency, and a
+single score that tells you whether things are getting better or worse. Then it
+points at the concrete waste and tells you how to fix it.
+
+No account. No API key. No data leaves your machine — it just reads the logs
+Claude Code already keeps locally.
+
+```
+$ npx tonik
+
+╭─ Usage · tinaba96 · 14d ──────────────╮ ╭─ Score ────╮
+│ ▁▂▃▅▇▆▄▃▂▄▆█             ↓ 18%        │ │            │
+│ in 4.2M   out 1.1M   cost $38.20      │ │  ⬢ 72/100  │
+╰───────────────────────────────────────╯ │   ▲ +6     │
+╭─ Health ──────────────────────────────╮ ╰────────────╯
+│ sessions 63   turns/session 7.4 ⚠     │
+│ cache hit 41% ⚠                        │
+╰────────────────────────────────────────╯
+╭─ Findings ────────────────────────────────────────────╮
+│ ✂ low cache reuse — $9.10 spent re-creating context   │
+│ ✂ 7.4 turns/session — try splitting prompts           │
+╰────────────────────────────────────────────────────────╯
+```
+
+## Install
+
+```sh
+npx tonik          # run without installing
+npm i -g tonik     # or install globally
+```
+
+## Usage
+
+```sh
+tonik                 # dashboard for the current project (last 14 days)
+tonik --global        # all projects combined
+tonik --since 7d      # change the time window
+tonik --theme card    # switch visual theme (dashboard | minimal | card)
+tonik --json          # machine-readable output (for CI / scripts)
+```
+
+## How the score works
+
+The score is intentionally transparent — it's the sum of three explainable
+sub-scores, each grounded in numbers you can verify:
+
+| Sub-score | Max | Based on |
+| --- | --- | --- |
+| Efficiency | 40 | Cache hit rate (reused context ÷ created context) |
+| Conversation | 30 | Avg human turns per session (fewer, well-scoped is better) |
+| Cost discipline | 30 | Token spend trend over the window (improving earns more) |
+
+No magic, no black box. If you don't like the weighting, it's open source.
+
+## Roadmap
+
+- `tonik fix` — apply the suggested improvements, not just list them
+- More themes and custom color palettes
+- A `tonik-core` library so other tools can reuse the analysis
+
+## License
+
+[MIT](./LICENSE) © Takahiro Inaba

package/dist/cli.js

@@ -0,0 +1,420 @@
+#!/usr/bin/env node
+
+// src/cli.tsx
+import { render } from "ink";
+
+// src/logs.ts
+import { createReadStream } from "fs";
+import { readdir, stat } from "fs/promises";
+import { createInterface } from "readline";
+import { homedir } from "os";
+import { join } from "path";
+var PROJECTS_DIR = join(homedir(), ".claude", "projects");
+function cwdToProjectDir(cwd) {
+  return cwd.replace(/[^a-zA-Z0-9]/g, "-");
+}
+function projectLabel(projectDir) {
+  const parts = projectDir.split("-").filter(Boolean);
+  return parts[parts.length - 1] ?? projectDir;
+}
+function num(v) {
+  return typeof v === "number" && Number.isFinite(v) ? v : 0;
+}
+function isHumanPrompt(record) {
+  if (record?.type !== "user") return false;
+  if (record.toolUseResult || record.isMeta) return false;
+  const content = record?.message?.content;
+  if (typeof content === "string") return content.length > 0;
+  if (Array.isArray(content)) {
+    return content.some((b) => b?.type === "text" || typeof b === "string");
+  }
+  return false;
+}
+function parseLine(line, project, since) {
+  let record;
+  try {
+    record = JSON.parse(line);
+  } catch {
+    return null;
+  }
+  const ts = record?.timestamp ? Date.parse(record.timestamp) : NaN;
+  if (!Number.isFinite(ts) || ts < since) return null;
+  const usage = record?.message?.usage;
+  return {
+    ts,
+    type: record?.type ?? "unknown",
+    sessionId: record?.sessionId ?? "unknown",
+    project,
+    model: record?.message?.model ?? null,
+    input: num(usage?.input_tokens),
+    output: num(usage?.output_tokens),
+    cacheRead: num(usage?.cache_read_input_tokens),
+    cacheCreation: num(usage?.cache_creation_input_tokens),
+    isHumanPrompt: isHumanPrompt(record)
+  };
+}
+async function readJsonl(file, project, since) {
+  const entries = [];
+  const rl = createInterface({
+    input: createReadStream(file, { encoding: "utf8" }),
+    crlfDelay: Infinity
+  });
+  for await (const line of rl) {
+    if (!line.trim()) continue;
+    const entry = parseLine(line, project, since);
+    if (entry) entries.push(entry);
+  }
+  return entries;
+}
+async function loadEntries(opts) {
+  let projectDirs;
+  try {
+    projectDirs = await readdir(PROJECTS_DIR);
+  } catch {
+    return [];
+  }
+  if (opts.projectDir) {
+    projectDirs = projectDirs.filter((d) => d === opts.projectDir);
+  }
+  const all = [];
+  for (const dir of projectDirs) {
+    const dirPath = join(PROJECTS_DIR, dir);
+    let files;
+    try {
+      const s = await stat(dirPath);
+      if (!s.isDirectory()) continue;
+      files = (await readdir(dirPath)).filter((f) => f.endsWith(".jsonl"));
+    } catch {
+      continue;
+    }
+    for (const f of files) {
+      try {
+        const entries = await readJsonl(join(dirPath, f), dir, opts.since);
+        all.push(...entries);
+      } catch {
+      }
+    }
+  }
+  return all;
+}
+
+// src/pricing.ts
+var PRICES = {
+  opus: { input: 15, output: 75, cacheWrite: 18.75, cacheRead: 1.5 },
+  sonnet: { input: 3, output: 15, cacheWrite: 3.75, cacheRead: 0.3 },
+  haiku: { input: 0.8, output: 4, cacheWrite: 1, cacheRead: 0.08 }
+};
+var DEFAULT_PRICE = PRICES.sonnet;
+function priceFor(model) {
+  if (!model) return DEFAULT_PRICE;
+  const m = model.toLowerCase();
+  if (m.includes("opus")) return PRICES.opus;
+  if (m.includes("sonnet")) return PRICES.sonnet;
+  if (m.includes("haiku")) return PRICES.haiku;
+  return DEFAULT_PRICE;
+}
+function entryCost(e) {
+  const p = priceFor(e.model);
+  return (e.input * p.input + e.output * p.output + e.cacheCreation * p.cacheWrite + e.cacheRead * p.cacheRead) / 1e6;
+}
+
+// src/metrics.ts
+var DAY_MS = 864e5;
+function clamp01(n) {
+  return Math.max(0, Math.min(1, n));
+}
+function computeMetrics(entries, opts) {
+  const totals = { input: 0, output: 0, cacheRead: 0, cacheCreation: 0 };
+  let cost = 0;
+  let wastedCost = 0;
+  const sessions = /* @__PURE__ */ new Set();
+  let humanPrompts = 0;
+  const startDay = Math.floor(opts.since / DAY_MS);
+  const daily = new Array(opts.windowDays).fill(0);
+  for (const e of entries) {
+    totals.input += e.input;
+    totals.output += e.output;
+    totals.cacheRead += e.cacheRead;
+    totals.cacheCreation += e.cacheCreation;
+    cost += entryCost(e);
+    wastedCost += e.cacheCreation * priceFor(e.model).cacheWrite / 1e6;
+    if (e.sessionId !== "unknown") sessions.add(e.sessionId);
+    if (e.isHumanPrompt) humanPrompts += 1;
+    const idx = Math.floor(e.ts / DAY_MS) - startDay;
+    if (idx >= 0 && idx < opts.windowDays) {
+      daily[idx] += e.input + e.output + e.cacheRead + e.cacheCreation;
+    }
+  }
+  const cacheDenom = totals.cacheRead + totals.cacheCreation;
+  const cacheHitRate = cacheDenom > 0 ? totals.cacheRead / cacheDenom : 0;
+  const sessionCount = sessions.size;
+  const avgTurns = sessionCount > 0 ? humanPrompts / sessionCount : 0;
+  const half = Math.floor(opts.windowDays / 2);
+  const firstHalf = daily.slice(0, half).reduce((a, b) => a + b, 0);
+  const secondHalf = daily.slice(half).reduce((a, b) => a + b, 0);
+  const span = firstHalf + secondHalf;
+  const trendReliable = firstHalf > 0 && span > 0 && firstHalf / span >= 0.1;
+  const trendPct = trendReliable ? (secondHalf - firstHalf) / firstHalf * 100 : 0;
+  const hasData = entries.length > 0 && (cacheDenom > 0 || sessionCount > 0);
+  const efficiency = clamp01(cacheHitRate / 0.8) * 40;
+  const conversation = sessionCount > 0 ? clamp01((15 - avgTurns) / 10) * 30 : 0;
+  const costScore = !hasData ? 0 : trendReliable ? clamp01((20 - trendPct) / 30) * 30 : 20;
+  const subscores = {
+    efficiency: Math.round(efficiency),
+    conversation: Math.round(conversation),
+    cost: Math.round(costScore)
+  };
+  const score = subscores.efficiency + subscores.conversation + subscores.cost;
+  const findings = [];
+  if (cacheHitRate < 0.6 && wastedCost > 0.5) {
+    findings.push(
+      `low cache reuse (${Math.round(cacheHitRate * 100)}%) \u2014 $${wastedCost.toFixed(2)} spent re-creating context`
+    );
+  }
+  if (avgTurns > 7) {
+    findings.push(
+      `${avgTurns.toFixed(1)} turns/session \u2014 try splitting work into clearer, scoped prompts`
+    );
+  }
+  if (trendReliable && trendPct > 15) {
+    findings.push(
+      `token spend up ${Math.round(trendPct)}% this period \u2014 watch growing context size`
+    );
+  }
+  if (hasData && findings.length === 0) {
+    findings.push("looking efficient \u2014 no major waste detected. Keep it up!");
+  }
+  return {
+    scope: opts.scope,
+    windowDays: opts.windowDays,
+    totals,
+    cost,
+    wastedCost,
+    cacheHitRate,
+    sessions: sessionCount,
+    avgTurns,
+    trendPct,
+    daily,
+    score,
+    subscores,
+    findings,
+    hasData
+  };
+}
+
+// src/ui.tsx
+import { Box, Text } from "ink";
+
+// src/format.ts
+var BARS = "\u2581\u2582\u2583\u2584\u2585\u2586\u2587\u2588";
+function formatTokens(n) {
+  if (n >= 1e9) return `${(n / 1e9).toFixed(1)}B`;
+  if (n >= 1e6) return `${(n / 1e6).toFixed(1)}M`;
+  if (n >= 1e3) return `${(n / 1e3).toFixed(1)}K`;
+  return String(Math.round(n));
+}
+function formatCost(n) {
+  return `$${n.toFixed(2)}`;
+}
+function formatPct(n) {
+  const rounded = Math.round(n);
+  if (rounded > 0) return `\u2191 ${rounded}%`;
+  if (rounded < 0) return `\u2193 ${Math.abs(rounded)}%`;
+  return `\u2192 0%`;
+}
+function sparkline(values, width = 24) {
+  if (values.length === 0) return "";
+  const series = values.length > width ? values.slice(values.length - width) : values;
+  const max = Math.max(...series);
+  if (max <= 0) return BARS[0].repeat(series.length);
+  return series.map((v) => {
+    const i = Math.round(v / max * (BARS.length - 1));
+    return BARS[Math.max(0, Math.min(BARS.length - 1, i))];
+  }).join("");
+}
+
+// src/ui.tsx
+import { jsx, jsxs } from "react/jsx-runtime";
+function scoreColor(score) {
+  if (score >= 70) return "green";
+  if (score >= 40) return "yellow";
+  return "red";
+}
+function scoreLabel(score) {
+  if (score >= 80) return "excellent";
+  if (score >= 60) return "good";
+  if (score >= 40) return "fair";
+  return "needs work";
+}
+function Panel(props) {
+  return /* @__PURE__ */ jsxs(
+    Box,
+    {
+      borderStyle: "round",
+      borderColor: "gray",
+      flexDirection: "column",
+      paddingX: 1,
+      flexGrow: props.flexGrow,
+      minWidth: props.minWidth,
+      width: props.width,
+      children: [
+        /* @__PURE__ */ jsx(Text, { dimColor: true, children: props.title }),
+        props.children
+      ]
+    }
+  );
+}
+function warn(active) {
+  return active ? " \u26A0" : "";
+}
+function Dashboard({ m }) {
+  if (!m.hasData) {
+    return /* @__PURE__ */ jsx(Box, { paddingX: 1, paddingY: 1, children: /* @__PURE__ */ jsxs(Panel, { title: `tonik \xB7 ${m.scope}`, children: [
+      /* @__PURE__ */ jsxs(Text, { children: [
+        "No Claude Code usage found for this scope in the last ",
+        m.windowDays,
+        " days."
+      ] }),
+      /* @__PURE__ */ jsx(Text, { dimColor: true, children: "Try `tonik --global` or a wider window with `--since 30d`." })
+    ] }) });
+  }
+  const inTokens = m.totals.input + m.totals.cacheRead + m.totals.cacheCreation;
+  const trendColor = m.trendPct <= 0 ? "green" : m.trendPct <= 15 ? "yellow" : "red";
+  const cacheLow = m.cacheHitRate < 0.6;
+  const turnsHigh = m.avgTurns > 7;
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", paddingX: 1, paddingY: 1, children: [
+    /* @__PURE__ */ jsxs(Box, { children: [
+      /* @__PURE__ */ jsxs(Panel, { title: `Usage \xB7 ${m.scope} \xB7 ${m.windowDays}d`, flexGrow: 1, minWidth: 42, children: [
+        /* @__PURE__ */ jsxs(Box, { children: [
+          /* @__PURE__ */ jsx(Text, { color: "cyan", children: sparkline(m.daily) }),
+          /* @__PURE__ */ jsx(Box, { flexGrow: 1, justifyContent: "flex-end", children: /* @__PURE__ */ jsx(Text, { color: trendColor, children: formatPct(m.trendPct) }) })
+        ] }),
+        /* @__PURE__ */ jsxs(Text, { children: [
+          /* @__PURE__ */ jsx(Text, { dimColor: true, children: "in " }),
+          formatTokens(inTokens),
+          /* @__PURE__ */ jsx(Text, { dimColor: true, children: "   out " }),
+          formatTokens(m.totals.output),
+          /* @__PURE__ */ jsx(Text, { dimColor: true, children: "   cost " }),
+          /* @__PURE__ */ jsx(Text, { bold: true, children: formatCost(m.cost) })
+        ] })
+      ] }),
+      /* @__PURE__ */ jsx(Panel, { title: "Score", width: 16, children: /* @__PURE__ */ jsxs(Box, { flexDirection: "column", alignItems: "center", children: [
+        /* @__PURE__ */ jsxs(Text, { color: scoreColor(m.score), bold: true, children: [
+          "\u2B22 ",
+          m.score,
+          "/100"
+        ] }),
+        /* @__PURE__ */ jsx(Text, { dimColor: true, children: scoreLabel(m.score) })
+      ] }) })
+    ] }),
+    /* @__PURE__ */ jsxs(Panel, { title: "Health", children: [
+      /* @__PURE__ */ jsxs(Text, { children: [
+        /* @__PURE__ */ jsx(Text, { dimColor: true, children: "sessions " }),
+        m.sessions,
+        /* @__PURE__ */ jsx(Text, { dimColor: true, children: "   turns/session " }),
+        /* @__PURE__ */ jsxs(Text, { color: turnsHigh ? "yellow" : void 0, children: [
+          m.avgTurns.toFixed(1),
+          warn(turnsHigh)
+        ] }),
+        /* @__PURE__ */ jsx(Text, { dimColor: true, children: "   cache hit " }),
+        /* @__PURE__ */ jsxs(Text, { color: cacheLow ? "yellow" : "green", children: [
+          Math.round(m.cacheHitRate * 100),
+          "%",
+          warn(cacheLow)
+        ] })
+      ] }),
+      /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+        "score = efficiency ",
+        m.subscores.efficiency,
+        "/40 \xB7 conversation",
+        " ",
+        m.subscores.conversation,
+        "/30 \xB7 cost ",
+        m.subscores.cost,
+        "/30"
+      ] })
+    ] }),
+    /* @__PURE__ */ jsx(Panel, { title: "Findings", children: m.findings.map((f, i) => /* @__PURE__ */ jsxs(Text, { children: [
+      /* @__PURE__ */ jsx(Text, { color: f.startsWith("looking") ? "green" : "magenta", children: f.startsWith("looking") ? "\u2713 " : "\u2702 " }),
+      f
+    ] }, i)) })
+  ] });
+}
+
+// src/cli.tsx
+import { jsx as jsx2 } from "react/jsx-runtime";
+var DAY_MS2 = 864e5;
+function parseSince(v) {
+  if (!v) return 14;
+  const m = /^(\d+)\s*d?$/.exec(v.trim());
+  return m ? Math.max(1, parseInt(m[1], 10)) : 14;
+}
+function parseArgs(argv) {
+  const args = {
+    global: false,
+    sinceDays: 14,
+    theme: "dashboard",
+    json: false,
+    help: false,
+    command: null
+  };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === "--global" || a === "-g") args.global = true;
+    else if (a === "--json") args.json = true;
+    else if (a === "--help" || a === "-h") args.help = true;
+    else if (a === "--since") args.sinceDays = parseSince(argv[++i]);
+    else if (a.startsWith("--since=")) args.sinceDays = parseSince(a.slice("--since=".length));
+    else if (a === "--theme") args.theme = argv[++i] ?? "dashboard";
+    else if (a.startsWith("--theme=")) args.theme = a.slice("--theme=".length);
+    else if (!a.startsWith("-") && !args.command) args.command = a;
+  }
+  return args;
+}
+var HELP = `
+  tonik \u2014 score and tune how you use AI
+
+  Usage
+    $ tonik [command] [options]
+
+  Commands
+    (default)      Show the usage dashboard for the current project
+    fix            Apply suggested improvements (coming soon)
+    tips           Show detailed improvement tips (coming soon)
+
+  Options
+    -g, --global       Combine all projects instead of the current one
+        --since <Nd>   Time window in days (default: 14d)
+        --theme <name> Visual theme: dashboard (default)
+        --json         Output raw metrics as JSON
+    -h, --help         Show this help
+`;
+async function main() {
+  const args = parseArgs(process.argv.slice(2));
+  if (args.help) {
+    console.log(HELP);
+    return;
+  }
+  if (args.command === "fix" || args.command === "tips") {
+    console.log(`
+  tonik ${args.command} is coming soon \u2014 for now, see the Findings panel.
+`);
+    return;
+  }
+  const projectDir = args.global ? null : cwdToProjectDir(process.cwd());
+  const since = Date.now() - args.sinceDays * DAY_MS2;
+  const entries = await loadEntries({ projectDir, since });
+  const scope = args.global ? "all projects" : projectLabel(projectDir);
+  const metrics = computeMetrics(entries, { scope, windowDays: args.sinceDays, since });
+  if (args.json) {
+    console.log(JSON.stringify(metrics, null, 2));
+    return;
+  }
+  const app = render(/* @__PURE__ */ jsx2(Dashboard, { m: metrics }));
+  app.unmount();
+  await app.waitUntilExit();
+}
+main().catch((err) => {
+  console.error(err);
+  process.exitCode = 1;
+});

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "tonik",
+  "version": "0.1.0",
+  "description": "Score and tune how you use AI — right in your terminal.",
+  "type": "module",
+  "bin": {
+    "tonik": "dist/cli.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "dev": "tsx src/cli.tsx",
+    "build": "tsup src/cli.tsx --format esm --clean --target node18",
+    "start": "node dist/cli.js",
+    "typecheck": "tsc --noEmit"
+  },
+  "keywords": [
+    "cli",
+    "ai",
+    "claude",
+    "tokens",
+    "analytics",
+    "developer-tools",
+    "typescript",
+    "ink"
+  ],
+  "author": "Takahiro Inaba (@tinaba96)",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/tinaba96/tonik.git"
+  },
+  "homepage": "https://github.com/tinaba96/tonik#readme",
+  "dependencies": {
+    "ink": "^5.0.1",
+    "react": "^18.3.1"
+  },
+  "devDependencies": {
+    "@types/node": "^20.14.0",
+    "@types/react": "^18.3.3",
+    "tsup": "^8.1.0",
+    "tsx": "^4.16.0",
+    "typescript": "^5.5.0"
+  }
+}