@yurukusa/cc-speed 1.0.0

package/README.md

@@ -0,0 +1,50 @@
+# cc-speed
+
+> How fast does Claude Code actually work?
+
+Measures tool execution rate (tools/hour) per session — the pace at which Claude calls tools, classified into slow / medium / fast / burst tiers.
+
+## Usage
+
+```bash
+npx cc-speed
+npx cc-speed --json
+```
+
+Or open `index.html` in a browser and drag in `.jsonl` files.
+
+## Metrics
+
+- **Median tools/hr** — typical execution pace
+- **p90** — what a fast session looks like
+- **Pace tiers** — slow (<50) / medium (50–199) / fast (200–599) / burst (600+)
+- **Top sessions** — fastest sessions with tool count and duration
+
+## Sample output
+
+```
+cc-speed — How fast does Claude Code actually work?
+
+Sessions analyzed: 393
+
+Execution rate
+  median    99 tools/hr
+  mean     169 tools/hr
+  p90      410 tools/hr
+  max    1,435 tools/hr
+
+Pace tiers
+  slow    ██████░░░░░░░░░░░░░░░░   28%  <50 tools/hr — careful work
+  medium  ████████░░░░░░░░░░░░░░   38%  50–199 tools/hr
+  fast    ███████░░░░░░░░░░░░░░░   30%  200–599 tools/hr
+  burst   █░░░░░░░░░░░░░░░░░░░░░    3%  600+ tools/hr
+
+Fastest sessions
+  #1  1,435 tools/hr  — 12 tools in 1 min
+  #2  1,005 tools/hr  — 15 tools in 1 min
+  #3    851 tools/hr  — 20 tools in 1 min
+```
+
+## License
+
+MIT

package/cli.mjs

@@ -0,0 +1,220 @@
+#!/usr/bin/env node
+/**
+ * cc-speed — How fast does Claude Code actually work?
+ * Measures tool execution rate (tools/hour) per session.
+ * Shows pace tiers, median speed, and top burst sessions.
+ */
+
+import { readdirSync, statSync } from 'fs';
+import { createInterface } from 'readline';
+import { createReadStream } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+
+const args = process.argv.slice(2);
+const jsonMode = args.includes('--json');
+const showHelp = args.includes('--help') || args.includes('-h');
+
+if (showHelp) {
+  process.stdout.write(`cc-speed — How fast does Claude Code actually work?
+
+Usage:
+  npx cc-speed          # Tool execution rate analysis
+  npx cc-speed --json   # JSON output
+
+Metrics:
+  - Tools/hour rate per session (pace)
+  - Pace tiers: slow / medium / fast / burst
+  - Median, mean, p90 rate across sessions
+  - Top-speed session details
+`);
+  process.exit(0);
+}
+
+const C = {
+  reset: '\x1b[0m', bold: '\x1b[1m', dim: '\x1b[2m',
+  cyan: '\x1b[36m', green: '\x1b[32m', yellow: '\x1b[33m',
+  blue: '\x1b[34m', purple: '\x1b[35m', red: '\x1b[31m',
+};
+
+function bar(pct, width = 24) {
+  const filled = Math.round(pct * width);
+  return '█'.repeat(filled) + '░'.repeat(width - filled);
+}
+
+function humanNum(n) {
+  if (n >= 1e6) return (n / 1e6).toFixed(1) + 'M';
+  if (n >= 1e3) return (n / 1e3).toFixed(1) + 'K';
+  return n.toString();
+}
+
+function fmt(n) { return Math.round(n).toLocaleString(); }
+
+const claudeDir = join(homedir(), '.claude', 'projects');
+
+const sessions = [];
+
+async function processFile(filePath) {
+  return new Promise((resolve) => {
+    const rl = createInterface({
+      input: createReadStream(filePath),
+      crlfDelay: Infinity,
+    });
+
+    const timestamps = [];
+    let toolCount = 0;
+
+    rl.on('line', (line) => {
+      if (!line) return;
+      let d;
+      try { d = JSON.parse(line); } catch { return; }
+
+      // Grab timestamps
+      if (d.timestamp) {
+        const t = new Date(d.timestamp).getTime();
+        if (!isNaN(t)) timestamps.push(t);
+      }
+
+      // Count tool calls in assistant messages
+      const msg = d.message || d;
+      if (!msg || msg.role !== 'assistant') return;
+      for (const c of (msg.content || [])) {
+        if (c && c.type === 'tool_use') toolCount++;
+      }
+    });
+
+    rl.on('close', () => {
+      if (timestamps.length < 2 || toolCount < 3) {
+        resolve(null);
+        return;
+      }
+      let minTs = timestamps[0], maxTs = timestamps[0];
+      for (const t of timestamps) { if (t < minTs) minTs = t; if (t > maxTs) maxTs = t; }
+      const durationMin = (maxTs - minTs) / 60000;
+      if (durationMin < 0.5) {
+        resolve(null);
+        return;
+      }
+      const rate = toolCount / (durationMin / 60); // tools per hour
+      resolve({ rate, toolCount, durationMin });
+    });
+  });
+}
+
+async function main() {
+  let projectDirs;
+  try {
+    projectDirs = readdirSync(claudeDir);
+  } catch {
+    process.stderr.write(`Cannot read ${claudeDir}\n`);
+    process.exit(1);
+  }
+
+  const allFiles = [];
+  for (const pd of projectDirs) {
+    const pdPath = join(claudeDir, pd);
+    try {
+      const files = readdirSync(pdPath).filter(f => f.endsWith('.jsonl'));
+      for (const f of files) allFiles.push(join(pdPath, f));
+    } catch {}
+  }
+
+  const BATCH = 16;
+  for (let i = 0; i < allFiles.length; i += BATCH) {
+    const batch = allFiles.slice(i, i + BATCH);
+    const results = await Promise.all(batch.map(f => processFile(f)));
+    for (const r of results) {
+      if (r) sessions.push(r);
+    }
+  }
+
+  if (sessions.length === 0) {
+    process.stderr.write('No sessions with timing data found.\n');
+    process.exit(1);
+  }
+
+  const rates = sessions.map(s => s.rate).sort((a, b) => a - b);
+  const n = rates.length;
+  const median = rates[Math.floor(n / 2)];
+  const mean = rates.reduce((a, b) => a + b, 0) / n;
+  const p90 = rates[Math.floor(n * 0.9)];
+  const max = rates[n - 1];
+
+  const slow   = rates.filter(r => r < 50).length;
+  const medium = rates.filter(r => r >= 50   && r < 200).length;
+  const fast   = rates.filter(r => r >= 200  && r < 600).length;
+  const burst  = rates.filter(r => r >= 600).length;
+
+  // Top sessions by rate
+  const top = [...sessions].sort((a, b) => b.rate - a.rate).slice(0, 3);
+
+  if (jsonMode) {
+    process.stdout.write(JSON.stringify({
+      sessionsAnalyzed: n,
+      rate: {
+        median: Math.round(median),
+        mean: Math.round(mean),
+        p90: Math.round(p90),
+        max: Math.round(max),
+      },
+      tiers: { slow, medium, fast, burst },
+      topSessions: top.map(s => ({
+        rate: Math.round(s.rate),
+        tools: s.toolCount,
+        durationMin: Math.round(s.durationMin),
+      })),
+    }, null, 2) + '\n');
+    return;
+  }
+
+  // ── Pretty output ─────────────────────────────────────────────────────────
+  process.stdout.write(`\n${C.bold}${C.cyan}cc-speed${C.reset} — How fast does Claude Code actually work?\n\n`);
+  process.stdout.write(`${C.bold}Sessions analyzed:${C.reset} ${humanNum(n)}\n\n`);
+
+  // Speed summary
+  process.stdout.write(`${C.bold}Execution rate${C.reset}\n`);
+  process.stdout.write(`  median  ${C.bold}${C.green}${fmt(median)}${C.reset} tools/hr\n`);
+  process.stdout.write(`  mean    ${C.bold}${fmt(mean)}${C.reset} tools/hr\n`);
+  process.stdout.write(`  p90     ${C.bold}${fmt(p90)}${C.reset} tools/hr\n`);
+  process.stdout.write(`  max     ${C.bold}${C.purple}${fmt(max)}${C.reset} tools/hr\n`);
+  process.stdout.write(`\n`);
+
+  // Tier distribution
+  process.stdout.write(`${C.bold}Pace tiers${C.reset}\n`);
+  const tiers = [
+    ['slow  ', slow,   C.dim,    '<50 tools/hr   — careful, deliberate work'],
+    ['medium', medium, C.blue,   '50–199 tools/hr — steady pace'],
+    ['fast  ', fast,   C.green,  '200–599 tools/hr — moving quickly'],
+    ['burst ', burst,  C.purple, '600+ tools/hr   — full sprint'],
+  ];
+  for (const [label, count, color, desc] of tiers) {
+    const pct = count / n;
+    process.stdout.write(
+      `  ${label}  ${color}${bar(pct, 22)}${C.reset}  ${C.bold}${(pct * 100).toFixed(0).padStart(3)}%${C.reset}  ${C.dim}(${humanNum(count)})  ${desc}${C.reset}\n`
+    );
+  }
+  process.stdout.write(`\n`);
+
+  // Top sessions
+  process.stdout.write(`${C.bold}Fastest sessions${C.reset}\n`);
+  for (let i = 0; i < top.length; i++) {
+    const s = top[i];
+    process.stdout.write(
+      `  #${i + 1}  ${C.bold}${C.purple}${fmt(s.rate)}${C.reset} tools/hr  — ${s.toolCount} tools in ${Math.round(s.durationMin)} min\n`
+    );
+  }
+  process.stdout.write(`\n`);
+
+  // Insight
+  process.stdout.write(`${C.dim}─────────────────────────────────────────────${C.reset}\n`);
+  const burstPct = (burst / n * 100).toFixed(0);
+  if (burst / n >= 0.4) {
+    process.stdout.write(`${C.purple}${C.bold}${burstPct}% of sessions run at 600+ tools/hr.${C.reset}\n`);
+    process.stdout.write(`${C.dim}At median ${fmt(median)} tools/hr, that's ~${Math.round(median / 60)} tool calls per minute.${C.reset}\n`);
+  } else {
+    process.stdout.write(`${C.green}${C.bold}Median pace: ${fmt(median)} tools/hr${C.reset}${C.dim} — ${Math.round(median / 60)} tool calls/min.${C.reset}\n`);
+  }
+  process.stdout.write(`\n`);
+}
+
+main().catch(e => { process.stderr.write(e.message + '\n'); process.exit(1); });

package/index.html

@@ -0,0 +1,137 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width,initial-scale=1">
+<title>cc-speed — How fast does Claude Code work?</title>
+<style>
+  :root {
+    --bg:#0d1117;--surface:#161b22;--border:#30363d;--text:#e6edf3;--dim:#8b949e;
+    --green:#3fb950;--yellow:#d29922;--blue:#58a6ff;--purple:#bc8cff;--accent:#3fb950;
+  }
+  *{box-sizing:border-box;margin:0;padding:0;}
+  body{background:var(--bg);color:var(--text);font-family:'Segoe UI',system-ui,sans-serif;min-height:100vh;padding:2rem 1rem;}
+  .container{max-width:780px;margin:0 auto;}
+  h1{font-size:1.5rem;font-weight:700;margin-bottom:.25rem;}
+  h1 span{color:var(--accent);}
+  .subtitle{color:var(--dim);font-size:.9rem;margin-bottom:2rem;}
+  .upload-zone{border:2px dashed var(--border);border-radius:10px;padding:2.5rem;text-align:center;cursor:pointer;transition:border-color .2s;margin-bottom:2rem;}
+  .upload-zone:hover,.upload-zone.drag{border-color:var(--accent);background:#0f1e13;}
+  .upload-zone p{color:var(--dim);font-size:.9rem;margin-top:.5rem;}
+  .upload-btn{background:var(--accent);color:#0d1117;border:none;padding:.5rem 1.2rem;border-radius:6px;cursor:pointer;font-weight:600;font-size:.9rem;}
+  .demo-btn{background:transparent;border:1px solid var(--border);color:var(--dim);padding:.4rem 1rem;border-radius:6px;cursor:pointer;font-size:.85rem;margin-top:.75rem;}
+  .demo-btn:hover{border-color:var(--accent);color:var(--text);}
+  #results{display:none;}
+  .card{background:var(--surface);border:1px solid var(--border);border-radius:10px;padding:1.25rem 1.5rem;margin-bottom:1rem;}
+  .card-title{font-size:.8rem;font-weight:600;text-transform:uppercase;letter-spacing:.06em;color:var(--dim);margin-bottom:.75rem;}
+  .big-stats{display:grid;grid-template-columns:repeat(4,1fr);gap:.75rem;margin-bottom:1rem;}
+  .stat-box{background:var(--surface);border:1px solid var(--border);border-radius:10px;padding:1rem;text-align:center;}
+  .stat-val{font-size:1.6rem;font-weight:800;line-height:1;}
+  .stat-key{font-size:.75rem;color:var(--dim);margin-top:.3rem;}
+  .bar-row{display:flex;align-items:center;gap:.75rem;margin-bottom:.6rem;font-size:.85rem;}
+  .bar-label{width:70px;color:var(--dim);flex-shrink:0;}
+  .bar-track{flex:1;height:10px;background:var(--border);border-radius:5px;overflow:hidden;}
+  .bar-fill{height:100%;border-radius:5px;transition:width .6s ease;}
+  .bar-pct{width:42px;text-align:right;font-weight:600;}
+  .bar-count{width:55px;color:var(--dim);font-size:.78rem;}
+  .top-item{display:flex;align-items:center;gap:.75rem;padding:.4rem 0;border-bottom:1px solid var(--border);font-size:.85rem;}
+  .top-item:last-child{border:none;}
+  .top-rank{width:28px;color:var(--dim);font-size:.8rem;}
+  .top-rate{font-weight:700;color:var(--purple);min-width:70px;}
+  .top-detail{color:var(--dim);}
+  .insight{background:#0f1e13;border:1px solid var(--green);border-radius:8px;padding:1rem 1.25rem;font-size:.9rem;line-height:1.5;margin-bottom:1rem;}
+  .path-hint{background:#1e1a0c;border:1px solid var(--border);border-radius:6px;padding:.6rem 1rem;font-size:.8rem;color:var(--dim);font-family:monospace;margin-bottom:2rem;}
+  @media(max-width:540px){.big-stats{grid-template-columns:1fr 1fr;}}
+</style>
+</head>
+<body>
+<div class="container">
+  <h1><span>cc-speed</span></h1>
+  <p class="subtitle">How fast does Claude Code actually work?</p>
+  <div class="path-hint">📁 ~/.claude/projects/&lt;project&gt;/*.jsonl — drag files below</div>
+  <div class="upload-zone" id="dz">
+    <button class="upload-btn" onclick="document.getElementById('fi').click()">Upload JSONL files</button>
+    <p>or drag and drop from ~/.claude/projects/</p><br>
+    <button class="demo-btn" onclick="loadDemo()">Try with demo data</button>
+    <input type="file" id="fi" accept=".jsonl" multiple style="display:none" onchange="handleFiles(this.files)">
+  </div>
+  <div id="results">
+    <div class="big-stats">
+      <div class="stat-box"><div class="stat-val" id="vSessions" style="color:var(--blue)">—</div><div class="stat-key">sessions</div></div>
+      <div class="stat-box"><div class="stat-val" id="vMedian" style="color:var(--green)">—</div><div class="stat-key">median tools/hr</div></div>
+      <div class="stat-box"><div class="stat-val" id="vP90" style="color:var(--yellow)">—</div><div class="stat-key">p90 tools/hr</div></div>
+      <div class="stat-box"><div class="stat-val" id="vMax" style="color:var(--purple)">—</div><div class="stat-key">max tools/hr</div></div>
+    </div>
+    <div class="card">
+      <div class="card-title">Pace tiers</div>
+      <div class="bar-row"><span class="bar-label">slow</span><div class="bar-track"><div class="bar-fill" id="bSlow" style="background:var(--dim)"></div></div><span class="bar-pct" id="pSlow">—</span><span class="bar-count" id="cSlow"></span></div>
+      <div class="bar-row"><span class="bar-label">medium</span><div class="bar-track"><div class="bar-fill" id="bMed" style="background:var(--blue)"></div></div><span class="bar-pct" id="pMed">—</span><span class="bar-count" id="cMed"></span></div>
+      <div class="bar-row"><span class="bar-label">fast</span><div class="bar-track"><div class="bar-fill" id="bFast" style="background:var(--green)"></div></div><span class="bar-pct" id="pFast">—</span><span class="bar-count" id="cFast"></span></div>
+      <div class="bar-row"><span class="bar-label">burst</span><div class="bar-track"><div class="bar-fill" id="bBurst" style="background:var(--purple)"></div></div><span class="bar-pct" id="pBurst">—</span><span class="bar-count" id="cBurst"></span></div>
+      <p style="font-size:.75rem;color:var(--dim);margin-top:.75rem">slow &lt;50 &nbsp;|&nbsp; medium 50–199 &nbsp;|&nbsp; fast 200–599 &nbsp;|&nbsp; burst 600+ (tools/hr)</p>
+    </div>
+    <div class="card">
+      <div class="card-title">Fastest sessions</div>
+      <div id="topList"></div>
+    </div>
+    <div id="insightBox"></div>
+  </div>
+</div>
+<script>
+const dz=document.getElementById('dz');
+dz.addEventListener('dragover',e=>{e.preventDefault();dz.classList.add('drag');});
+dz.addEventListener('dragleave',()=>dz.classList.remove('drag'));
+dz.addEventListener('drop',e=>{e.preventDefault();dz.classList.remove('drag');handleFiles(e.dataTransfer.files);});
+function handleFiles(files){
+  Promise.all([...files].map(f=>new Promise((res,rej)=>{const r=new FileReader();r.onload=e=>res(e.target.result);r.onerror=rej;r.readAsText(f);})))
+    .then(texts=>analyze(texts.join('\n')));
+}
+function analyze(raw){
+  const sessionMap={};
+  for(const line of raw.split('\n')){
+    if(!line)continue;
+    let d;try{d=JSON.parse(line);}catch{continue;}
+    const sid=d.sessionId||d.session_id||'x';
+    if(!sessionMap[sid])sessionMap[sid]={ts:[],tools:0};
+    if(d.timestamp){const t=new Date(d.timestamp).getTime();if(!isNaN(t))sessionMap[sid].ts.push(t);}
+    const msg=d.message||d;
+    if(msg&&msg.role==='assistant')for(const c of(msg.content||[]))if(c&&c.type==='tool_use')sessionMap[sid].tools++;
+  }
+  const sessions=[];
+  for(const s of Object.values(sessionMap)){
+    if(s.ts.length<2||s.tools<3)continue;
+    let mn=s.ts[0],mx=s.ts[0];for(const t of s.ts){if(t<mn)mn=t;if(t>mx)mx=t;}
+    const dur=(mx-mn)/60000;if(dur<0.5)continue;
+    sessions.push({rate:s.tools/(dur/60),tools:s.tools,dur});
+  }
+  if(!sessions.length){alert('No sessions with timing data found.');return;}
+  const rates=sessions.map(s=>s.rate).sort((a,b)=>a-b);
+  const n=rates.length;
+  const median=rates[Math.floor(n/2)];
+  const mean=rates.reduce((a,b)=>a+b,0)/n;
+  const p90=rates[Math.floor(n*0.9)];
+  const max=rates[n-1];
+  const slow=rates.filter(r=>r<50).length;
+  const med=rates.filter(r=>r>=50&&r<200).length;
+  const fast=rates.filter(r=>r>=200&&r<600).length;
+  const burst=rates.filter(r=>r>=600).length;
+  const top=[...sessions].sort((a,b)=>b.rate-a.rate).slice(0,5);
+  render({n,median,mean,p90,max,slow,med,fast,burst,top});
+}
+function hn(n){return n>=1e3?(n/1e3).toFixed(1)+'K':Math.round(n).toLocaleString();}
+function pct(a,t){return t?Math.round(a/t*100):0;}
+function render(d){
+  document.getElementById('results').style.display='block';
+  document.getElementById('vSessions').textContent=hn(d.n);
+  document.getElementById('vMedian').textContent=hn(d.median);
+  document.getElementById('vP90').textContent=hn(d.p90);
+  document.getElementById('vMax').textContent=hn(d.max);
+  const sb=(bId,pId,cId,n)=>{const p=pct(n,d.n);document.getElementById(bId).style.width=p+'%';document.getElementById(pId).textContent=p+'%';document.getElementById(cId).textContent='('+n+')';};
+  sb('bSlow','pSlow','cSlow',d.slow);sb('bMed','pMed','cMed',d.med);sb('bFast','pFast','cFast',d.fast);sb('bBurst','pBurst','cBurst',d.burst);
+  document.getElementById('topList').innerHTML=d.top.map((s,i)=>`<div class="top-item"><span class="top-rank">#${i+1}</span><span class="top-rate">${hn(s.rate)} /hr</span><span class="top-detail">${s.tools} tools in ${Math.round(s.dur)} min</span></div>`).join('');
+  document.getElementById('insightBox').innerHTML=`<div class="insight"><strong>Median: ${hn(d.median)} tools/hr</strong> — that's ~${Math.round(d.median/60)} tool calls per minute.<br>Top ${pct(d.fast+d.burst,d.n)}% of sessions run at 200+ tools/hr. Burst sessions hit ${hn(d.max)} tools/hr.</div>`;
+}
+function loadDemo(){render({n:393,median:99,mean:169,p90:410,max:1435,slow:112,med:150,fast:119,burst:12,top:[{rate:1435,tools:12,dur:1},{rate:1005,tools:15,dur:1},{rate:851,tools:20,dur:1},{rate:720,tools:18,dur:1.5},{rate:600,tools:25,dur:2.5}]});}
+</script>
+</body>
+</html>

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "@yurukusa/cc-speed",
+  "version": "1.0.0",
+  "description": "How fast does Claude Code actually work? Tool execution rate (tools/hour), pace tiers, and burst session analysis.",
+  "type": "module",
+  "bin": {
+    "cc-speed": "./cli.mjs"
+  },
+  "scripts": {
+    "start": "node cli.mjs"
+  },
+  "keywords": [
+    "claude",
+    "claude-code",
+    "ai",
+    "developer-tools",
+    "analytics",
+    "performance"
+  ],
+  "author": "yurukusa",
+  "license": "MIT",
+  "engines": {
+    "node": ">=18"
+  }
+}