cc-output 1.0.0

package/README.md

@@ -0,0 +1,59 @@
+# cc-output
+
+See how much text Claude Code generated for you.
+
+```
+npx cc-output
+```
+
+```
+  cc-output — Claude Code Output Volume
+  ══════════════════════════════════════════
+
+  ▸ Overview
+    Output tokens:     20,468,061
+    ≈ Words:           15,351,046  (×0.75/token)
+    ≈ Pages:           61,404      (÷250 words)
+    ≈ Novels:          192         (÷80,000 words)
+    Sessions:          3,877
+    Cache hit rate:    96.3%
+
+  ▸ Output by project
+    ~/ (home)               ██████████████████   12.9M  62.8%
+    projects-cc-loop        ██████████░░░░░░░░    7.4M  35.9%
+    ...
+
+  ▸ Monthly output
+    2026-02  ██████████████████  16.9M
+    2026-01  ███░░░░░░░░░░░░░░░   2.7M
+
+  ▸ Most verbose sessions
+     5.1M  projects/cc-loop/2fa937ff-a7c6-...
+     1.1M  projects/-home-namakusa/56d7f7ab-...
+```
+
+## Browser version
+
+Drag and drop your `~/.claude` folder at:
+**https://yurukusa.github.io/cc-output/**
+
+Nothing is uploaded. All analysis runs locally in your browser.
+
+## Options
+
+```bash
+npx cc-output           # interactive output
+npx cc-output --json    # JSON output for scripting
+```
+
+## What it measures
+
+- **Output tokens** — every token Claude generated in response to you
+- **Words / Pages / Novels** — human-readable equivalents (0.75 words/token, 250 words/page, 80,000 words/novel)
+- **By project** — which projects got the most output
+- **Monthly trend** — output volume over time
+- **Top sessions** — your most verbose conversations
+
+## Part of cc-toolkit
+
+One of [60 free tools](https://yurukusa.github.io/cc-toolkit/) for Claude Code users.

package/cli.mjs

@@ -0,0 +1,247 @@
+#!/usr/bin/env node
+
+// cc-output — See how much text Claude Code generated for you.
+// Zero dependencies. Reads ~/.claude/projects/ session transcripts.
+
+import { readdir, stat, open } from 'node:fs/promises';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import { createInterface } from 'node:readline';
+import { createReadStream } from 'node:fs';
+
+const CONCURRENCY = 8;
+
+// Approximations
+const WORDS_PER_TOKEN = 0.75;
+const WORDS_PER_PAGE = 250;
+const WORDS_PER_NOVEL = 80000;
+
+const C = {
+  reset: '\x1b[0m', bold: '\x1b[1m', dim: '\x1b[2m',
+  red: '\x1b[31m', green: '\x1b[32m', yellow: '\x1b[33m',
+  cyan: '\x1b[36m', blue: '\x1b[34m',
+};
+
+function bar(pct, width = 22) {
+  const filled = Math.round(pct * width);
+  return '█'.repeat(filled) + '░'.repeat(width - filled);
+}
+
+function projectName(dir) {
+  const stripped = dir.replace(/^-home-[^-]+/, '').replace(/^-/, '');
+  return stripped || '~/ (home)';
+}
+
+function fmtTokens(n) {
+  if (n >= 1_000_000) return (n / 1_000_000).toFixed(1) + 'M';
+  if (n >= 1_000) return (n / 1_000).toFixed(1) + 'K';
+  return String(n);
+}
+
+async function analyzeFile(filePath) {
+  let outputTokens = 0;
+  let inputTokens = 0;
+  let cacheReadTokens = 0;
+  let cacheCreationTokens = 0;
+  let firstTimestamp = null;
+
+  const rl = createInterface({
+    input: createReadStream(filePath),
+    crlfDelay: Infinity,
+  });
+
+  for await (const line of rl) {
+    if (!line || !line.includes('"usage"')) continue;
+    let data;
+    try { data = JSON.parse(line); } catch { continue; }
+
+    // Extract timestamp
+    if (!firstTimestamp) {
+      const ts = data.timestamp || data.ts;
+      if (ts) firstTimestamp = ts;
+    }
+
+    const msg = data.message || data;
+    if (!msg || typeof msg !== 'object') continue;
+    const usage = msg.usage;
+    if (!usage || typeof usage !== 'object') continue;
+
+    if (typeof usage.output_tokens === 'number') outputTokens += usage.output_tokens;
+    if (typeof usage.input_tokens === 'number') inputTokens += usage.input_tokens;
+    if (typeof usage.cache_read_input_tokens === 'number') cacheReadTokens += usage.cache_read_input_tokens;
+    if (typeof usage.cache_creation_input_tokens === 'number') cacheCreationTokens += usage.cache_creation_input_tokens;
+  }
+
+  return { outputTokens, inputTokens, cacheReadTokens, cacheCreationTokens, firstTimestamp };
+}
+
+async function scan() {
+  const projectsDir = join(homedir(), '.claude', 'projects');
+  let projectDirs;
+  try { projectDirs = await readdir(projectsDir); } catch { return null; }
+
+  const tasks = [];
+  for (const pd of projectDirs) {
+    const pp = join(projectsDir, pd);
+    const ps = await stat(pp).catch(() => null);
+    if (!ps?.isDirectory()) continue;
+    const files = await readdir(pp).catch(() => []);
+    for (const f of files) {
+      if (f.endsWith('.jsonl')) {
+        tasks.push({ path: join(pp, f), project: projectName(pd) });
+      }
+    }
+    // Subagent files
+    for (const f of files) {
+      const sp = join(pp, f, 'subagents');
+      const ss = await stat(sp).catch(() => null);
+      if (!ss?.isDirectory()) continue;
+      const sfs = await readdir(sp).catch(() => []);
+      for (const sf of sfs) {
+        if (sf.endsWith('.jsonl')) {
+          tasks.push({ path: join(sp, sf), project: projectName(pd) });
+        }
+      }
+    }
+  }
+
+  let totalOutput = 0, totalInput = 0, totalCacheRead = 0, totalCacheCreate = 0;
+  let sessionsWithOutput = 0;
+  const byProject = {};   // project -> outputTokens
+  const byMonth = {};     // YYYY-MM -> outputTokens
+  const topSessions = []; // { outputTokens, path }
+
+  // Process in batches
+  for (let i = 0; i < tasks.length; i += CONCURRENCY) {
+    const batch = tasks.slice(i, i + CONCURRENCY);
+    const results = await Promise.all(batch.map(async t => {
+      const st = await stat(t.path).catch(() => null);
+      if (!st || st.size < 100) return null;
+      const r = await analyzeFile(t.path).catch(() => null);
+      return r ? { ...r, project: t.project, path: t.path } : null;
+    }));
+
+    for (const r of results) {
+      if (!r || r.outputTokens === 0) continue;
+      totalOutput += r.outputTokens;
+      totalInput += r.inputTokens;
+      totalCacheRead += r.cacheReadTokens;
+      totalCacheCreate += r.cacheCreationTokens;
+      sessionsWithOutput++;
+
+      if (!byProject[r.project]) byProject[r.project] = 0;
+      byProject[r.project] += r.outputTokens;
+
+      if (r.firstTimestamp) {
+        const month = r.firstTimestamp.slice(0, 7);
+        if (!byMonth[month]) byMonth[month] = 0;
+        byMonth[month] += r.outputTokens;
+      }
+
+      topSessions.push({ tokens: r.outputTokens, path: r.path });
+    }
+  }
+
+  // Sort top sessions
+  topSessions.sort((a, b) => b.tokens - a.tokens);
+
+  return { totalOutput, totalInput, totalCacheRead, totalCacheCreate, sessionsWithOutput, byProject, byMonth, topSessions };
+}
+
+const jsonMode = process.argv.includes('--json');
+if (!jsonMode) process.stdout.write(`  ${C.dim}Counting tokens...${C.reset}\r`);
+
+const data = await scan();
+if (!data) {
+  console.error('Could not read ~/.claude/projects/');
+  process.exit(1);
+}
+
+const { totalOutput, totalInput, totalCacheRead, totalCacheCreate, sessionsWithOutput, byProject, byMonth, topSessions } = data;
+
+const words = Math.round(totalOutput * WORDS_PER_TOKEN);
+const pages = Math.round(words / WORDS_PER_PAGE);
+const novels = Math.round(words / WORDS_PER_NOVEL);
+const cacheHitRate = (totalInput + totalCacheRead + totalCacheCreate) > 0
+  ? totalCacheRead / (totalInput + totalCacheRead + totalCacheCreate)
+  : 0;
+
+if (jsonMode) {
+  const byProjectSorted = Object.entries(byProject)
+    .sort((a, b) => b[1] - a[1])
+    .map(([name, tokens]) => ({ name, tokens }));
+  const byMonthSorted = Object.entries(byMonth)
+    .sort((a, b) => b[0].localeCompare(a[0]))
+    .map(([month, tokens]) => ({ month, tokens }));
+  console.log(JSON.stringify({
+    version: '1.0.0',
+    totalOutputTokens: totalOutput,
+    totalInputTokens: totalInput,
+    cacheReadTokens: totalCacheRead,
+    cacheHitRate: +cacheHitRate.toFixed(3),
+    sessionsWithOutput,
+    equivalents: { words, pages, novels },
+    byProject: byProjectSorted,
+    byMonth: byMonthSorted,
+    topSessions: topSessions.slice(0, 10).map(s => ({ tokens: s.tokens, path: s.path.split('/').slice(-3).join('/') })),
+  }, null, 2));
+  process.exit(0);
+}
+
+// ── Display ──────────────────────────────────────────────────────
+
+console.log(`\n  ${C.bold}${C.cyan}cc-output — Claude Code Output Volume${C.reset}`);
+console.log(`  ${'═'.repeat(42)}`);
+
+console.log(`\n  ${C.bold}▸ Overview${C.reset}`);
+console.log(`    Output tokens:     ${C.bold}${totalOutput.toLocaleString()}${C.reset}`);
+console.log(`    ≈ Words:           ${C.bold}${C.green}${words.toLocaleString()}${C.reset}${C.dim}  (×0.75/token)${C.reset}`);
+console.log(`    ≈ Pages:           ${C.bold}${C.green}${pages.toLocaleString()}${C.reset}${C.dim}  (÷250 words)${C.reset}`);
+console.log(`    ≈ Novels:          ${C.bold}${C.yellow}${novels.toLocaleString()}${C.reset}${C.dim}  (÷80,000 words)${C.reset}`);
+console.log(`    Sessions:          ${C.dim}${sessionsWithOutput.toLocaleString()}${C.reset}`);
+console.log(`    Cache hit rate:    ${C.dim}${(cacheHitRate * 100).toFixed(1)}%${C.reset}`);
+
+// By project
+const projList = Object.entries(byProject)
+  .sort((a, b) => b[1] - a[1])
+  .slice(0, 8);
+
+if (projList.length > 0) {
+  console.log(`\n  ${C.bold}▸ Output by project${C.reset}`);
+  const maxProj = projList[0][1];
+  for (const [name, tokens] of projList) {
+    const pct = totalOutput > 0 ? tokens / totalOutput : 0;
+    const b = bar(tokens / maxProj, 18);
+    console.log(`    ${C.cyan}${name.slice(0, 24).padEnd(24)}${C.reset}  ${C.dim}${b}${C.reset}  ${fmtTokens(tokens).padStart(6)}  ${C.dim}${(pct * 100).toFixed(1)}%${C.reset}`);
+  }
+}
+
+// Monthly breakdown
+const monthList = Object.entries(byMonth)
+  .sort((a, b) => b[0].localeCompare(a[0]))
+  .slice(0, 6);
+
+if (monthList.length > 0) {
+  console.log(`\n  ${C.bold}▸ Monthly output${C.reset}`);
+  const maxMonth = Math.max(...monthList.map(([, v]) => v));
+  for (const [month, tokens] of monthList) {
+    const b = bar(tokens / maxMonth, 18);
+    console.log(`    ${C.dim}${month}${C.reset}  ${b}  ${C.bold}${fmtTokens(tokens)}${C.reset}`);
+  }
+}
+
+// Top sessions
+const topN = topSessions.slice(0, 6);
+if (topN.length > 0) {
+  console.log(`\n  ${C.bold}▸ Most verbose sessions${C.reset}`);
+  for (const s of topN) {
+    const label = s.path.split('/').slice(-3).join('/').slice(0, 55);
+    console.log(`    ${C.yellow}${fmtTokens(s.tokens).padStart(6)}${C.reset}  ${C.dim}${label}${C.reset}`);
+  }
+}
+
+console.log();
+console.log(`  ${C.dim}─── Share ───${C.reset}`);
+console.log(`  ${C.dim}Claude Code generated ${novels} novels worth of text for me (${totalOutput.toLocaleString()} output tokens)`);
+console.log(`  #ClaudeCode${C.reset}`);
+console.log();

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "cc-output",
+  "version": "1.0.0",
+  "description": "See how much text Claude Code generated for you. Output tokens, words, pages, and novel equivalents across all sessions.",
+  "bin": {
+    "cc-output": "cli.mjs"
+  },
+  "type": "module",
+  "keywords": [
+    "claude-code",
+    "claude",
+    "ai",
+    "tokens",
+    "output",
+    "analytics",
+    "productivity",
+    "stats"
+  ],
+  "author": "yurukusa",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/yurukusa/cc-output.git"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "files": [
+    "cli.mjs",
+    "README.md",
+    "LICENSE"
+  ]
+}