cc-compact 1.0.0

package/README.md

@@ -0,0 +1,65 @@
+# cc-compact
+
+How often does Claude Code hit the context limit? Shows compaction frequency, pre-compaction token counts, and trigger type breakdown.
+
+```
+cc-compact — Claude Code context compaction stats
+
+  Total sessions:       755
+  Sessions compacted:   137 (18.1% of sessions)
+  Total compactions:    912
+  Avg per compacted:    6.7 compactions/session
+  Trigger:              883 auto  /  29 manual
+
+  Pre-compaction context size:
+    Min:    71.1K tokens
+    Avg:    163.9K tokens
+    Median: 167.3K tokens
+    Max:    190.3K tokens
+
+────────────────────────────────────────────────────────
+  Context size at compaction
+
+  <100K       ░░░░░░░░░░░░░░░░░░░░░░░░     9  (1.0%)
+  100–150K    ░░░░░░░░░░░░░░░░░░░░░░░░     9  (1.0%)
+  150–175K    ████████████████████████   870  (95.4%)
+  175K+       █░░░░░░░░░░░░░░░░░░░░░░░    24  (2.6%)
+```
+
+## Usage
+
+```bash
+npx cc-compact          # Compaction frequency and token stats
+npx cc-compact --json   # JSON output
+```
+
+## What it shows
+
+- **Compaction rate** — percentage of sessions that hit the context limit
+- **Total compactions** — how many times Claude Code auto-compacted
+- **Trigger breakdown** — auto (limit hit) vs manual (/compact command)
+- **Pre-compaction size** — context size at the moment of compaction
+- **Size distribution** — where in the token range compactions happen
+- **Monthly trend** — compaction frequency over time
+- **By project** — which projects burn through context fastest
+
+## What compaction means
+
+When Claude Code's context window fills up, it automatically compacts (summarizes) the conversation to free up space. This is called an "auto" compaction.
+
+- **Auto compaction** (96.8% of cases): hit the limit, context summarized automatically
+- **Manual compaction** (3.2% of cases): user typed `/compact` before hitting the limit
+
+95.4% of auto-compactions happen between 150K–175K tokens — just below the typical 200K context limit.
+
+## Privacy
+
+Reads session files looking for compaction event markers. No content is transmitted. Everything runs locally.
+
+## Browser version
+
+Drop your `~/.claude` folder into [cc-compact on the web](https://yurukusa.github.io/cc-compact/) — no install required.
+
+---
+
+Part of [cc-toolkit](https://yurukusa.github.io/cc-toolkit/) — 87 free tools for Claude Code

package/cli.mjs

@@ -0,0 +1,274 @@
+#!/usr/bin/env node
+/**
+ * cc-compact — How often does Claude Code compact your context?
+ * Shows compaction frequency, pre-compaction token counts, and trigger types.
+ */
+
+import { readdirSync, statSync, createReadStream } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+import { createInterface } from 'readline';
+
+const args = process.argv.slice(2);
+const jsonMode = args.includes('--json');
+const showHelp = args.includes('--help') || args.includes('-h');
+
+if (showHelp) {
+  console.log(`cc-compact — How often does Claude Code compact your context?
+
+Usage:
+  npx cc-compact          # Compaction frequency and token statistics
+  npx cc-compact --json   # JSON output
+`);
+  process.exit(0);
+}
+
+const claudeDir = join(homedir(), '.claude', 'projects');
+
+function getISOMonth(date) {
+  return `${date.getFullYear()}-${String(date.getMonth() + 1).padStart(2, '0')}`;
+}
+
+function projectName(dirName) {
+  const stripped = dirName.replace(/^-home-[^-]+/, '').replace(/^-/, '');
+  return stripped || '~/ (home)';
+}
+
+function humanTok(n) {
+  if (n >= 1e6) return (n / 1e6).toFixed(1) + 'M';
+  if (n >= 1e3) return (n / 1e3).toFixed(1) + 'K';
+  return n.toString();
+}
+
+// Accumulators
+let totalSessions = 0;
+let sessionsWithCompaction = 0;
+let totalCompactions = 0;
+let autoCompactions = 0;
+let manualCompactions = 0;
+const preTokens = [];       // all pre-compaction token counts
+const byMonth = {};          // { month: { compactions, sessions, preTokenSum } }
+const byProject = {};        // { projDir: { compactions, sessions, preTokenSum, name } }
+
+let projectDirs;
+try {
+  projectDirs = readdirSync(claudeDir);
+} catch {
+  console.error(`Cannot read ${claudeDir}`);
+  process.exit(1);
+}
+
+async function processFile(filePath, projDir) {
+  return new Promise((resolve) => {
+    const rl = createInterface({ input: createReadStream(filePath), crlfDelay: Infinity });
+    const mtime = new Date(statSync(filePath).mtime);
+    const month = getISOMonth(mtime);
+    const projLabel = projectName(projDir);
+
+    let fileCompactions = 0;
+    let filePreTokens = [];
+
+    rl.on('line', (line) => {
+      if (!line.includes('"compact_boundary"')) return;
+
+      const mPre     = line.match(/"preTokens":(\d+)/);
+      const mTrigger = line.match(/"trigger":"([^"]+)"/);
+
+      const pre     = mPre     ? parseInt(mPre[1], 10) : 0;
+      const trigger = mTrigger ? mTrigger[1] : 'auto';
+
+      fileCompactions++;
+      if (trigger === 'manual') manualCompactions++;
+      else autoCompactions++;
+      if (pre > 0) {
+        preTokens.push(pre);
+        filePreTokens.push(pre);
+      }
+    });
+
+    rl.on('close', () => {
+      totalSessions++;
+      if (fileCompactions > 0) {
+        sessionsWithCompaction++;
+        totalCompactions += fileCompactions;
+
+        if (!byMonth[month]) byMonth[month] = { compactions: 0, sessions: 0, preTokenSum: 0, preTokenCount: 0 };
+        byMonth[month].compactions += fileCompactions;
+        byMonth[month].sessions++;
+        byMonth[month].preTokenSum += filePreTokens.reduce((a, b) => a + b, 0);
+        byMonth[month].preTokenCount += filePreTokens.length;
+
+        if (!byProject[projDir]) byProject[projDir] = { compactions: 0, sessions: 0, preTokenSum: 0, preTokenCount: 0, name: projLabel };
+        byProject[projDir].compactions += fileCompactions;
+        byProject[projDir].sessions++;
+        byProject[projDir].preTokenSum += filePreTokens.reduce((a, b) => a + b, 0);
+        byProject[projDir].preTokenCount += filePreTokens.length;
+      } else {
+        if (!byMonth[month]) byMonth[month] = { compactions: 0, sessions: 0, preTokenSum: 0, preTokenCount: 0 };
+        if (!byProject[projDir]) byProject[projDir] = { compactions: 0, sessions: 0, preTokenSum: 0, preTokenCount: 0, name: projLabel };
+      }
+
+      resolve();
+    });
+  });
+}
+
+// Collect files
+const filesToProcess = [];
+for (const projDir of projectDirs) {
+  const projPath = join(claudeDir, projDir);
+  let stat;
+  try {
+    stat = statSync(projPath);
+    if (!stat.isDirectory()) continue;
+  } catch { continue; }
+
+  let entries;
+  try { entries = readdirSync(projPath); } catch { continue; }
+
+  for (const entry of entries) {
+    if (!entry.endsWith('.jsonl')) continue;
+    if (entry.includes('subagent')) continue;
+    const filePath = join(projPath, entry);
+    try {
+      if (!statSync(filePath).isFile()) continue;
+    } catch { continue; }
+    filesToProcess.push({ filePath, projDir });
+  }
+}
+
+if (!filesToProcess.length) {
+  console.error('No session files found.');
+  process.exit(1);
+}
+
+if (!jsonMode) process.stderr.write(`Scanning ${filesToProcess.length} sessions...\r`);
+
+const CONCURRENCY = 16;
+for (let i = 0; i < filesToProcess.length; i += CONCURRENCY) {
+  const batch = filesToProcess.slice(i, i + CONCURRENCY);
+  await Promise.all(batch.map(({ filePath, projDir }) => processFile(filePath, projDir)));
+}
+
+if (!jsonMode) process.stderr.write(' '.repeat(40) + '\r');
+
+// Compute stats
+preTokens.sort((a, b) => a - b);
+const medianPre = preTokens.length ? preTokens[Math.floor(preTokens.length / 2)] : 0;
+const avgPre = preTokens.length ? Math.round(preTokens.reduce((a, b) => a + b, 0) / preTokens.length) : 0;
+const maxPre = preTokens.length ? preTokens[preTokens.length - 1] : 0;
+const minPre = preTokens.length ? preTokens[0] : 0;
+
+// Distribution buckets: < 100K, 100K–150K, 150K–175K, 175K+
+const buckets = {
+  '<100K':   preTokens.filter(t => t < 100000).length,
+  '100–150K': preTokens.filter(t => t >= 100000 && t < 150000).length,
+  '150–175K': preTokens.filter(t => t >= 150000 && t < 175000).length,
+  '175K+':   preTokens.filter(t => t >= 175000).length,
+};
+
+if (jsonMode) {
+  const sortedMonths = Object.entries(byMonth).sort((a, b) => a[0].localeCompare(b[0]));
+  const sortedProjects = Object.entries(byProject)
+    .filter(([, d]) => d.compactions > 0)
+    .sort((a, b) => b[1].compactions - a[1].compactions);
+  console.log(JSON.stringify({
+    total_sessions: totalSessions,
+    sessions_with_compaction: sessionsWithCompaction,
+    compaction_rate_pct: Math.round(sessionsWithCompaction / totalSessions * 1000) / 10,
+    total_compactions: totalCompactions,
+    auto_compactions: autoCompactions,
+    manual_compactions: manualCompactions,
+    pre_tokens: {
+      min: minPre,
+      median: medianPre,
+      avg: avgPre,
+      max: maxPre,
+    },
+    token_distribution: buckets,
+    by_month: Object.fromEntries(sortedMonths.map(([m, d]) => [m, {
+      compactions: d.compactions,
+      sessions_compacted: d.sessions,
+      avg_pre_tokens: d.preTokenCount > 0 ? Math.round(d.preTokenSum / d.preTokenCount) : 0,
+    }])),
+    by_project: sortedProjects.slice(0, 10).map(([, d]) => ({
+      project: d.name,
+      compactions: d.compactions,
+      sessions_compacted: d.sessions,
+      avg_pre_tokens: d.preTokenCount > 0 ? Math.round(d.preTokenSum / d.preTokenCount) : 0,
+    })),
+  }, null, 2));
+  process.exit(0);
+}
+
+// Terminal display
+const BAR_WIDTH = 24;
+const now = new Date();
+const curMonth = getISOMonth(now);
+
+function rpad(str, len) {
+  return str + ' '.repeat(Math.max(0, len - str.length));
+}
+
+function countBar(n, max) {
+  const filled = max > 0 ? Math.round((n / max) * BAR_WIDTH) : 0;
+  return '█'.repeat(filled) + '░'.repeat(BAR_WIDTH - filled);
+}
+
+const compactionRatePct = (sessionsWithCompaction / totalSessions * 100).toFixed(1);
+const avgPerCompacted = sessionsWithCompaction > 0 ? (totalCompactions / sessionsWithCompaction).toFixed(1) : '0';
+
+console.log('cc-compact — Claude Code context compaction stats\n');
+
+console.log(`  Total sessions:       ${totalSessions.toLocaleString()}`);
+console.log(`  Sessions compacted:   ${sessionsWithCompaction.toLocaleString()} (${compactionRatePct}% of sessions)`);
+console.log(`  Total compactions:    ${totalCompactions.toLocaleString()}`);
+console.log(`  Avg per compacted:    ${avgPerCompacted} compactions/session`);
+console.log(`  Trigger:              ${autoCompactions} auto  /  ${manualCompactions} manual`);
+
+console.log();
+console.log('  Pre-compaction context size:');
+console.log(`    Min:    ${humanTok(minPre)} tokens`);
+console.log(`    Avg:    ${humanTok(avgPre)} tokens`);
+console.log(`    Median: ${humanTok(medianPre)} tokens`);
+console.log(`    Max:    ${humanTok(maxPre)} tokens`);
+
+// Distribution of pre-compaction sizes
+console.log('\n' + '─'.repeat(56));
+console.log('  Context size at compaction\n');
+const maxBucket = Math.max(...Object.values(buckets));
+for (const [label, count] of Object.entries(buckets)) {
+  const pct = preTokens.length > 0 ? (count / preTokens.length * 100).toFixed(1) : '0.0';
+  console.log(`  ${label.padEnd(10)}  ${countBar(count, maxBucket)}  ${String(count).padStart(4)}  (${pct}%)`);
+}
+
+// Monthly chart
+const sortedMonths = Object.entries(byMonth)
+  .filter(([, d]) => d.compactions > 0)
+  .sort((a, b) => a[0].localeCompare(b[0]))
+  .slice(-12);
+if (sortedMonths.length) {
+  console.log('\n' + '─'.repeat(56));
+  console.log('  Monthly compactions\n');
+  const maxMonthCount = Math.max(...sortedMonths.map(([, d]) => d.compactions));
+  for (const [month, data] of sortedMonths) {
+    const tag = month === curMonth ? ' (in progress)' : '';
+    console.log(`  ${month}  ${countBar(data.compactions, maxMonthCount)}  ${String(data.compactions).padStart(4)}${tag}`);
+  }
+}
+
+// Project chart (top 8)
+const sortedProjects = Object.entries(byProject)
+  .filter(([, d]) => d.compactions > 0)
+  .sort((a, b) => b[1].compactions - a[1].compactions)
+  .slice(0, 8);
+if (sortedProjects.length) {
+  console.log('\n' + '─'.repeat(56));
+  console.log('  By project (top 8)\n');
+  const maxProjCount = sortedProjects[0][1].compactions;
+  const maxLabel = Math.max(...sortedProjects.map(([, d]) => d.name.length));
+  for (const [, data] of sortedProjects) {
+    const label = rpad(data.name, maxLabel);
+    console.log(`  ${label}  ${countBar(data.compactions, maxProjCount)}  ${String(data.compactions).padStart(4)}`);
+  }
+}

package/index.html

@@ -0,0 +1,299 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0">
+<title>cc-compact — Claude Code compaction stats</title>
+<style>
+  * { box-sizing: border-box; margin: 0; padding: 0; }
+  body {
+    background: #0d1117;
+    color: #c9d1d9;
+    font-family: 'SF Mono', 'Consolas', 'Cascadia Code', monospace;
+    min-height: 100vh;
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    padding: 40px 20px;
+  }
+  h1 { font-size: 1.5rem; color: #f7c948; margin-bottom: 6px; }
+  .subtitle { color: #8b949e; font-size: 0.875rem; margin-bottom: 32px; }
+
+  .drop-zone {
+    border: 2px dashed #30363d;
+    border-radius: 12px;
+    padding: 48px 64px;
+    text-align: center;
+    cursor: pointer;
+    transition: all 0.2s;
+    max-width: 480px;
+    width: 100%;
+    margin-bottom: 32px;
+  }
+  .drop-zone:hover, .drop-zone.drag-over { border-color: #f7c948; background: rgba(247,201,72,0.05); }
+  .drop-text { color: #8b949e; font-size: 0.875rem; line-height: 1.6; }
+  .drop-text strong { color: #c9d1d9; }
+  #file-input { display: none; }
+
+  .progress { display: none; max-width: 480px; width: 100%; text-align: center; margin-bottom: 24px; }
+  .progress.visible { display: block; }
+  .progress-bar-track { height: 6px; background: #21262d; border-radius: 3px; overflow: hidden; margin: 12px 0; }
+  .progress-bar-fill { height: 100%; background: #f7c948; border-radius: 3px; transition: width 0.1s; }
+  .progress-label { color: #8b949e; font-size: 0.78rem; }
+
+  .result { display: none; max-width: 620px; width: 100%; }
+  .result.visible { display: block; }
+  .card { background: #161b22; border: 1px solid #30363d; border-radius: 8px; padding: 20px; margin-bottom: 16px; }
+  .card-title { color: #8b949e; font-size: 0.75rem; text-transform: uppercase; letter-spacing: 1px; margin-bottom: 16px; }
+
+  .stats-grid { display: grid; grid-template-columns: repeat(2, 1fr); gap: 12px; margin-bottom: 16px; }
+  @media (min-width: 500px) { .stats-grid { grid-template-columns: repeat(3, 1fr); } }
+  .stat-item { text-align: center; }
+  .stat-val { font-size: 1.2rem; color: #f7c948; font-weight: 700; }
+  .stat-lbl { font-size: 0.68rem; color: #8b949e; margin-top: 2px; }
+
+  .trigger-row { display: flex; justify-content: center; gap: 32px; padding: 12px; background: #21262d; border-radius: 6px; margin-top: 12px; }
+  .trigger-item { text-align: center; }
+  .trigger-val { font-size: 1.1rem; font-weight: 700; }
+  .trigger-auto { color: #ff7b72; }
+  .trigger-manual { color: #58a6ff; }
+  .trigger-lbl { font-size: 0.68rem; color: #8b949e; margin-top: 2px; }
+
+  .tok-stats { display: grid; grid-template-columns: repeat(2, 1fr); gap: 8px; margin-top: 12px; }
+  @media (min-width: 500px) { .tok-stats { grid-template-columns: repeat(4, 1fr); } }
+  .tok-item { text-align: center; padding: 8px; background: #21262d; border-radius: 4px; }
+  .tok-val { font-size: 0.9rem; color: #f7c948; font-weight: 600; }
+  .tok-lbl { font-size: 0.65rem; color: #8b949e; margin-top: 2px; }
+
+  .bar-chart { font-size: 0.78rem; }
+  .bar-row { display: flex; align-items: center; gap: 8px; margin-bottom: 6px; }
+  .bar-label { width: 72px; text-align: right; color: #8b949e; flex-shrink: 0; }
+  .bar-label-wide { width: 150px; text-align: right; color: #c9d1d9; flex-shrink: 0; white-space: nowrap; overflow: hidden; text-overflow: ellipsis; }
+  .bar-track { flex: 1; height: 14px; background: #21262d; border-radius: 3px; overflow: hidden; }
+  .bar-fill { height: 100%; background: #f7c948; border-radius: 3px; transition: width 0.5s ease; }
+  .bar-count { width: 56px; color: #8b949e; text-align: right; flex-shrink: 0; font-size: 0.72rem; }
+
+  .section-title { color: #8b949e; font-size: 0.72rem; text-transform: uppercase; letter-spacing: 1px; margin-bottom: 10px; margin-top: 16px; }
+  .section-title:first-child { margin-top: 0; }
+
+  .reset-btn { margin-top: 16px; background: none; border: 1px solid #30363d; color: #8b949e; padding: 8px 16px; border-radius: 6px; cursor: pointer; font-family: inherit; font-size: 0.8rem; display: block; width: 100%; transition: all 0.2s; }
+  .reset-btn:hover { border-color: #f7c948; color: #f7c948; }
+  .footer { color: #8b949e; font-size: 0.75rem; text-align: center; margin-top: 12px; }
+  .footer a { color: #f7c948; text-decoration: none; }
+  .footer a:hover { text-decoration: underline; }
+</style>
+</head>
+<body>
+<h1>🗜️ cc-compact</h1>
+<p class="subtitle">How often does Claude Code hit the context limit?</p>
+
+<div class="drop-zone" id="drop-zone">
+  <div style="font-size:2.5rem;margin-bottom:12px;">📁</div>
+  <div class="drop-text">
+    <strong>Drop your ~/.claude folder here</strong><br>
+    or click to select<br><br>
+    Reads session files for compaction events.<br>
+    Nothing is uploaded. Processing is fast.
+  </div>
+  <input type="file" id="file-input" webkitdirectory multiple accept=".jsonl">
+</div>
+
+<div class="progress" id="progress">
+  <div class="progress-label" id="progress-label">Processing sessions...</div>
+  <div class="progress-bar-track"><div class="progress-bar-fill" id="progress-fill" style="width:0%"></div></div>
+</div>
+
+<div class="result" id="result">
+  <div class="card">
+    <div class="card-title">Compaction Summary</div>
+    <div class="stats-grid">
+      <div class="stat-item"><div class="stat-val" id="stat-sessions">—</div><div class="stat-lbl">sessions</div></div>
+      <div class="stat-item"><div class="stat-val" id="stat-rate">—%</div><div class="stat-lbl">hit context limit</div></div>
+      <div class="stat-item"><div class="stat-val" id="stat-total">—</div><div class="stat-lbl">total compactions</div></div>
+      <div class="stat-item"><div class="stat-val" id="stat-avg">—</div><div class="stat-lbl">per compacted session</div></div>
+      <div class="stat-item"><div class="stat-val" id="stat-median">—</div><div class="stat-lbl">median context size</div></div>
+      <div class="stat-item"><div class="stat-val" id="stat-max">—</div><div class="stat-lbl">max context size</div></div>
+    </div>
+    <div class="trigger-row">
+      <div class="trigger-item"><div class="trigger-val trigger-auto" id="trig-auto">—</div><div class="trigger-lbl">🔴 auto (limit hit)</div></div>
+      <div class="trigger-item"><div class="trigger-val trigger-manual" id="trig-manual">—</div><div class="trigger-lbl">🔵 manual (/compact)</div></div>
+    </div>
+  </div>
+
+  <div class="card">
+    <div class="section-title">Context size at compaction</div>
+    <div class="bar-chart" id="bucket-chart"></div>
+    <div class="section-title">Monthly compactions</div>
+    <div class="bar-chart" id="month-chart"></div>
+    <div class="section-title">By project (top 8)</div>
+    <div class="bar-chart" id="proj-chart"></div>
+  </div>
+
+  <button class="reset-btn" id="reset-btn">← Analyze another folder</button>
+</div>
+
+<div class="footer">
+  <a href="https://github.com/yurukusa/cc-compact" target="_blank">cc-compact</a> ·
+  Part of <a href="https://yurukusa.github.io/cc-toolkit/" target="_blank">cc-toolkit</a> · 106 free tools for Claude Code
+</div>
+
+<script>
+const dropZone = document.getElementById('drop-zone');
+const fileInput = document.getElementById('file-input');
+const resultEl = document.getElementById('result');
+const progressEl = document.getElementById('progress');
+const progressFill = document.getElementById('progress-fill');
+const progressLabel = document.getElementById('progress-label');
+const resetBtn = document.getElementById('reset-btn');
+
+dropZone.addEventListener('click', () => fileInput.click());
+dropZone.addEventListener('dragover', e => { e.preventDefault(); dropZone.classList.add('drag-over'); });
+dropZone.addEventListener('dragleave', () => dropZone.classList.remove('drag-over'));
+dropZone.addEventListener('drop', e => { e.preventDefault(); dropZone.classList.remove('drag-over'); processFiles(e.dataTransfer.files); });
+fileInput.addEventListener('change', () => processFiles(fileInput.files));
+resetBtn.addEventListener('click', () => { resultEl.classList.remove('visible'); progressEl.classList.remove('visible'); dropZone.style.display = ''; fileInput.value = ''; });
+
+function humanTok(n) {
+  if (n >= 1e6) return (n / 1e6).toFixed(1) + 'M';
+  if (n >= 1e3) return (n / 1e3).toFixed(1) + 'K';
+  return n.toString();
+}
+
+function projectName(webkitPath) {
+  const parts = webkitPath.split('/');
+  const projIdx = parts.indexOf('projects');
+  if (projIdx >= 0 && parts[projIdx + 1]) {
+    const dir = parts[projIdx + 1];
+    const stripped = dir.replace(/^-home-[^-]+/, '').replace(/^-/, '');
+    return stripped || '~/ (home)';
+  }
+  return 'unknown';
+}
+
+function getMonth(file) {
+  const d = new Date(file.lastModified);
+  return `${d.getFullYear()}-${String(d.getMonth()+1).padStart(2,'0')}`;
+}
+
+async function parseFile(file) {
+  const text = await file.text();
+  const lines = text.split('\n');
+  let compactions = 0, auto = 0, manual = 0;
+  const filePreTokens = [];
+  for (const line of lines) {
+    if (!line.includes('"compact_boundary"')) continue;
+    const mPre = line.match(/"preTokens":(\d+)/);
+    const mTrig = line.match(/"trigger":"([^"]+)"/);
+    const pre = mPre ? parseInt(mPre[1], 10) : 0;
+    const trig = mTrig ? mTrig[1] : 'auto';
+    compactions++;
+    if (trig === 'manual') manual++;
+    else auto++;
+    if (pre > 0) filePreTokens.push(pre);
+  }
+  return { compactions, auto, manual, preTokens: filePreTokens };
+}
+
+async function processFiles(files) {
+  const jsonlFiles = Array.from(files).filter(f => {
+    const p = f.webkitRelativePath || f.name;
+    return p.endsWith('.jsonl') && !p.includes('/subagents/');
+  });
+  if (!jsonlFiles.length) { alert('No session files found.'); return; }
+
+  dropZone.style.display = 'none';
+  progressEl.classList.add('visible');
+
+  let totalSessions = 0, sessionsCompacted = 0, totalCompactions = 0, totalAuto = 0, totalManual = 0;
+  const allPreTokens = [];
+  const byMonth = {}, byProj = {};
+
+  for (let i = 0; i < jsonlFiles.length; i++) {
+    const f = jsonlFiles[i];
+    progressLabel.textContent = `Processing ${i + 1} / ${jsonlFiles.length}...`;
+    progressFill.style.width = ((i + 1) / jsonlFiles.length * 100) + '%';
+
+    let data;
+    try { data = await parseFile(f); } catch { continue; }
+
+    totalSessions++;
+    if (data.compactions > 0) {
+      sessionsCompacted++;
+      totalCompactions += data.compactions;
+      totalAuto  += data.auto;
+      totalManual += data.manual;
+      allPreTokens.push(...data.preTokens);
+
+      const month = getMonth(f);
+      if (!byMonth[month]) byMonth[month] = 0;
+      byMonth[month] += data.compactions;
+
+      const proj = projectName(f.webkitRelativePath || f.name);
+      if (!byProj[proj]) byProj[proj] = 0;
+      byProj[proj] += data.compactions;
+    }
+
+    if (i % 20 === 0) await new Promise(r => setTimeout(r, 0));
+  }
+
+  progressEl.classList.remove('visible');
+
+  allPreTokens.sort((a, b) => a - b);
+  const median = allPreTokens.length ? allPreTokens[Math.floor(allPreTokens.length / 2)] : 0;
+  const max = allPreTokens.length ? allPreTokens[allPreTokens.length - 1] : 0;
+  const rate = totalSessions > 0 ? (sessionsCompacted / totalSessions * 100) : 0;
+  const avgPerCompacted = sessionsCompacted > 0 ? (totalCompactions / sessionsCompacted).toFixed(1) : '0';
+
+  document.getElementById('stat-sessions').textContent = totalSessions.toLocaleString();
+  document.getElementById('stat-rate').textContent = rate.toFixed(1) + '%';
+  document.getElementById('stat-total').textContent = totalCompactions.toLocaleString();
+  document.getElementById('stat-avg').textContent = avgPerCompacted;
+  document.getElementById('stat-median').textContent = humanTok(median);
+  document.getElementById('stat-max').textContent = humanTok(max);
+  document.getElementById('trig-auto').textContent = totalAuto.toLocaleString();
+  document.getElementById('trig-manual').textContent = totalManual.toLocaleString();
+
+  // Bucket chart
+  const buckets = [
+    ['<100K',    allPreTokens.filter(t => t < 100000).length],
+    ['100–150K', allPreTokens.filter(t => t >= 100000 && t < 150000).length],
+    ['150–175K', allPreTokens.filter(t => t >= 150000 && t < 175000).length],
+    ['175K+',    allPreTokens.filter(t => t >= 175000).length],
+  ];
+  const maxBucket = Math.max(...buckets.map(([,n])=>n), 1);
+  document.getElementById('bucket-chart').innerHTML = buckets.map(([label, count]) => {
+    const pct = allPreTokens.length ? (count / allPreTokens.length * 100).toFixed(1) : '0.0';
+    return `<div class="bar-row">
+      <div class="bar-label">${label}</div>
+      <div class="bar-track"><div class="bar-fill" style="width:${(count/maxBucket*100).toFixed(1)}%"></div></div>
+      <div class="bar-count">${count} (${pct}%)</div>
+    </div>`;
+  }).join('');
+
+  // Monthly chart
+  const months = Object.entries(byMonth).sort((a,b) => a[0].localeCompare(b[0])).slice(-12);
+  const maxMonth = Math.max(...months.map(([,n])=>n), 1);
+  document.getElementById('month-chart').innerHTML = months.map(([m, n]) =>
+    `<div class="bar-row">
+      <div class="bar-label">${m}</div>
+      <div class="bar-track"><div class="bar-fill" style="width:${(n/maxMonth*100).toFixed(1)}%"></div></div>
+      <div class="bar-count">${n}</div>
+    </div>`
+  ).join('');
+
+  // Project chart
+  const projs = Object.entries(byProj).sort((a,b) => b[1]-a[1]).slice(0, 8);
+  const maxProj = projs[0]?.[1] || 1;
+  document.getElementById('proj-chart').innerHTML = projs.map(([name, n]) =>
+    `<div class="bar-row">
+      <div class="bar-label-wide">${name}</div>
+      <div class="bar-track"><div class="bar-fill" style="width:${(n/maxProj*100).toFixed(1)}%"></div></div>
+      <div class="bar-count">${n}</div>
+    </div>`
+  ).join('');
+
+  resultEl.classList.add('visible');
+}
+</script>
+</body>
+</html>

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "cc-compact",
+  "version": "1.0.0",
+  "description": "How often does Claude Code compact your context? Compaction frequency, pre-compaction token counts, and trigger types.",
+  "type": "module",
+  "bin": {
+    "cc-compact": "./cli.mjs"
+  },
+  "scripts": {
+    "start": "node cli.mjs"
+  },
+  "keywords": [
+    "claude",
+    "claude-code",
+    "ai",
+    "developer-tools",
+    "analytics",
+    "context"
+  ],
+  "author": "yurukusa",
+  "license": "MIT",
+  "engines": {
+    "node": ">=18"
+  }
+}