cc-gap 1.0.0

package/README.md

@@ -0,0 +1,77 @@
+# cc-gap
+
+**How long does your AI rest between sessions?**
+
+Analyzes the time gaps between consecutive Claude Code sessions to reveal your work rhythm — from instant compaction restarts to multi-day breaks.
+
+## Usage
+
+```bash
+npx cc-gap
+```
+
+Or use the browser version (no install):
+
+→ **[yurukusa.github.io/cc-gap](https://yurukusa.github.io/cc-gap/)**
+
+Drag in your `~/.claude` folder. Everything runs locally — nothing is uploaded.
+
+## Sample output
+
+```
+cc-gap — Time between your Claude Code sessions (All time)
+
+488 sessions · 487 gaps analyzed
+
+  < 1 min    ████████████████████████░░░░  119  ( 24%)
+  1–5 min    ███████████████░░░░░░░░░░░░░   79  ( 16%)
+  5–30 min   ████████████████████████████  148  ( 30%)
+  30m–2h     █████████░░░░░░░░░░░░░░░░░░░   46  (  9%)
+  2–8 hr     ██████████░░░░░░░░░░░░░░░░░░   51  ( 10%)
+  8–24 hr    ██████░░░░░░░░░░░░░░░░░░░░░░   31  (  6%)
+  1–2 days   ██░░░░░░░░░░░░░░░░░░░░░░░░░░   13  (  3%)
+  2–7 days   ░░░░░░░░░░░░░░░░░░░░░░░░░░░░    0  (  0%)
+  7+ days    ░░░░░░░░░░░░░░░░░░░░░░░░░░░░    0  (  0%)
+
+───────────────────────────────────────────────────────
+  Work style:   🔄 Rapid Cycler
+  Quick breaks between sessions. Fast iteration rhythm.
+
+  Median gap:  7m
+  Mean gap:    2h 29m
+  P90 gap:     7h 34m
+  Longest gap: 1d 23h
+  < 1 min (compaction):  24.4% of gaps
+```
+
+## Work style classifications
+
+| Type | Median gap | Description |
+|------|-----------|-------------|
+| ⚡ Always On | < 2 min | The AI barely pauses — continuous autonomous work |
+| 🔄 Rapid Cycler | 2–30 min | Quick breaks, fast iteration rhythm |
+| ⏸️ Steady Pauser | 30 min–4 hr | Natural pauses between focused bursts |
+| 🌙 Daily Worker | 4–24 hr | Sessions in work windows with overnight breaks |
+| 📅 Weekend Coder | > 24 hr | Infrequent sessions with multi-day breaks |
+
+## Options
+
+```bash
+npx cc-gap              # All-time analysis
+npx cc-gap --days=30   # Last 30 days
+npx cc-gap --json      # JSON output for dashboards
+```
+
+## Part of cc-toolkit
+
+cc-gap is tool #47 in [cc-toolkit](https://yurukusa.github.io/cc-toolkit/) — 49 free tools for Claude Code users.
+
+Related tools:
+- [cc-session-length](https://github.com/yurukusa/cc-session-length) — How long do sessions last?
+- [cc-night-owl](https://github.com/yurukusa/cc-night-owl) — Which hours does your AI work most?
+- [cc-streak](https://github.com/yurukusa/cc-streak) — Consecutive days of usage
+
+---
+
+**GitHub**: [yurukusa/cc-gap](https://github.com/yurukusa/cc-gap)
+**Try it**: `npx cc-gap`

package/cli.mjs

@@ -0,0 +1,208 @@
+#!/usr/bin/env node
+import { readdir, open } from 'fs/promises';
+import { join } from 'path';
+import { homedir } from 'os';
+
+const VERSION = '1.0.0';
+const MAX_CHUNK = 4096;
+
+function parseArgs(argv) {
+  const args = { days: 0, json: false, utc: false };
+  for (const a of argv.slice(2)) {
+    if (a.startsWith('--days=')) args.days = parseInt(a.slice(7)) || 0;
+    else if (a === '--json') args.json = true;
+    else if (a === '--utc') args.utc = true;
+    else if (a === '--help' || a === '-h') {
+      console.log([
+        `cc-gap v${VERSION}`,
+        '',
+        'Usage: cc-gap [options]',
+        '',
+        'Options:',
+        '  --days=N    Only analyze sessions from the last N days',
+        '  --json      Output JSON for piping',
+        '  --help      Show this help',
+        '',
+        'Shows the distribution of time gaps between consecutive Claude Code sessions.',
+      ].join('\n'));
+      process.exit(0);
+    }
+  }
+  return args;
+}
+
+async function getFirstTimestamp(path) {
+  let fh;
+  try {
+    fh = await open(path, 'r');
+    const buf = Buffer.alloc(MAX_CHUNK);
+    const { bytesRead } = await fh.read(buf, 0, MAX_CHUNK, 0);
+    const text = buf.subarray(0, bytesRead).toString('utf8');
+    for (const line of text.split('\n')) {
+      if (!line.trim()) continue;
+      try {
+        const d = JSON.parse(line);
+        if (d.timestamp) return new Date(d.timestamp);
+      } catch {}
+    }
+  } catch {}
+  finally { await fh?.close(); }
+  return null;
+}
+
+async function collectStarts(claudeDir, cutoff) {
+  const starts = [];
+  let projectDirs;
+  try { projectDirs = await readdir(claudeDir); } catch { return starts; }
+
+  for (const pd of projectDirs) {
+    const pdPath = join(claudeDir, pd);
+    let files;
+    try { files = await readdir(pdPath); } catch { continue; }
+    for (const name of files) {
+      if (!name.endsWith('.jsonl')) continue;
+      const ts = await getFirstTimestamp(join(pdPath, name));
+      if (!ts) continue;
+      if (cutoff && ts < cutoff) continue;
+      starts.push(ts);
+    }
+  }
+  return starts;
+}
+
+const BUCKETS = [
+  { label: '< 1 min',   min: 0,     max: 1,      cls: 'instant' },
+  { label: '1–5 min',   min: 1,     max: 5,      cls: 'quick' },
+  { label: '5–30 min',  min: 5,     max: 30,     cls: 'quick' },
+  { label: '30m–2h',    min: 30,    max: 120,    cls: 'medium' },
+  { label: '2–8 hr',    min: 120,   max: 480,    cls: 'medium' },
+  { label: '8–24 hr',   min: 480,   max: 1440,   cls: 'long' },
+  { label: '1–2 days',  min: 1440,  max: 2880,   cls: 'long' },
+  { label: '2–7 days',  min: 2880,  max: 10080,  cls: 'long' },
+  { label: '7+ days',   min: 10080, max: Infinity, cls: 'long' },
+];
+
+function fmtGap(min) {
+  if (min < 1) return `${Math.round(min * 60)}s`;
+  if (min < 60) return `${Math.round(min)}m`;
+  const h = Math.floor(min / 60);
+  const m = Math.round(min % 60);
+  if (h < 24) return m ? `${h}h ${m}m` : `${h}h`;
+  const d = Math.floor(h / 24);
+  const rh = h % 24;
+  return rh ? `${d}d ${rh}h` : `${d}d`;
+}
+
+function median(sorted) {
+  if (!sorted.length) return 0;
+  const m = Math.floor(sorted.length / 2);
+  return sorted.length % 2 ? sorted[m] : (sorted[m - 1] + sorted[m]) / 2;
+}
+
+function mean(arr) {
+  return arr.length ? arr.reduce((s, v) => s + v, 0) / arr.length : 0;
+}
+
+function classify(medianMin, pctInstant) {
+  if (pctInstant >= 0.5 || medianMin < 2)
+    return { label: '⚡ Always On', desc: 'Your AI barely pauses. Instant restarts, continuous work.' };
+  if (medianMin < 30)
+    return { label: '🔄 Rapid Cycler', desc: 'Quick breaks between sessions. Fast iteration rhythm.' };
+  if (medianMin < 240)
+    return { label: '⏸️  Steady Pauser', desc: 'Natural pauses between focused bursts.' };
+  if (medianMin < 1440)
+    return { label: '🌙 Daily Worker', desc: 'Sessions cluster in work windows with overnight breaks.' };
+  return { label: '📅 Weekend Coder', desc: 'Infrequent sessions with multi-day breaks between.' };
+}
+
+async function main() {
+  const args = parseArgs(process.argv);
+  const claudeDir = join(homedir(), '.claude', 'projects');
+  const cutoff = args.days ? new Date(Date.now() - args.days * 86400000) : null;
+
+  const starts = await collectStarts(claudeDir, cutoff);
+  if (starts.length < 2) {
+    console.log('Not enough sessions to compute gaps.');
+    process.exit(0);
+  }
+
+  starts.sort((a, b) => a - b);
+
+  const gapsMin = [];
+  for (let i = 1; i < starts.length; i++) {
+    const g = (starts[i] - starts[i - 1]) / 60000;
+    if (g >= 0 && g < 365 * 24 * 60) gapsMin.push(g);
+  }
+
+  const sorted = [...gapsMin].sort((a, b) => a - b);
+  const total = sorted.length;
+  const med = median(sorted);
+  const avg = mean(sorted);
+  const maxGap = sorted[total - 1];
+  const pctInstant = sorted.filter(g => g < 1).length / total;
+  const p90 = sorted[Math.floor(total * 0.9)];
+  const cls = classify(med, pctInstant);
+
+  const bucketCounts = BUCKETS.map(b => ({
+    ...b,
+    count: sorted.filter(g => g >= b.min && g < b.max).length,
+  }));
+
+  if (args.json) {
+    console.log(JSON.stringify({
+      sessions: starts.length,
+      gaps: total,
+      median: med,
+      mean: avg,
+      max: maxGap,
+      p90,
+      pctInstant,
+      classification: cls.label,
+      buckets: bucketCounts.map(b => ({ label: b.label, count: b.count, pct: b.count / total * 100 })),
+    }, null, 2));
+    return;
+  }
+
+  const scope = args.days ? `Last ${args.days} days` : 'All time';
+
+  const C = {
+    reset: '\x1b[0m', bold: '\x1b[1m',
+    purple: '\x1b[35m', cyan: '\x1b[36m',
+    yellow: '\x1b[33m', orange: '\x1b[38;5;214m',
+    muted: '\x1b[90m', green: '\x1b[32m',
+  };
+
+  const maxCount = Math.max(...bucketCounts.map(b => b.count), 1);
+
+  console.log(`\n${C.cyan}${C.bold}cc-gap${C.reset} — Time between your Claude Code sessions (${scope})\n`);
+  console.log(`${C.muted}${starts.length} sessions · ${total} gaps analyzed${C.reset}\n`);
+
+  for (const b of bucketCounts) {
+    const pct = (b.count / total * 100).toFixed(0);
+    const barWidth = Math.round(b.count / maxCount * 28);
+    const color = b.cls === 'instant' ? C.purple
+                : b.cls === 'quick'   ? C.cyan
+                : b.cls === 'medium'  ? C.yellow
+                : C.orange;
+    const filled = '█'.repeat(barWidth);
+    const empty  = '░'.repeat(28 - barWidth);
+    console.log(
+      `  ${C.muted}${b.label.padEnd(10)}${C.reset}  ` +
+      `${color}${filled}${C.muted}${empty}${C.reset}  ` +
+      `${C.muted}${String(b.count).padStart(4)}  (${String(pct).padStart(3)}%)${C.reset}`
+    );
+  }
+
+  console.log(`\n${'─'.repeat(55)}`);
+  console.log(`  ${C.cyan}Work style:${C.reset}   ${C.bold}${cls.label}${C.reset}`);
+  console.log(`  ${C.muted}${cls.desc}${C.reset}`);
+
+  console.log(`\n  ${C.muted}Median gap:${C.reset}  ${C.bold}${fmtGap(med)}${C.reset}`);
+  console.log(`  ${C.muted}Mean gap:${C.reset}    ${C.bold}${fmtGap(avg)}${C.reset}`);
+  console.log(`  ${C.muted}P90 gap:${C.reset}     ${C.bold}${fmtGap(p90)}${C.reset}`);
+  console.log(`  ${C.muted}Longest gap:${C.reset} ${C.orange}${C.bold}${fmtGap(maxGap)}${C.reset}`);
+  console.log(`  ${C.muted}< 1 min (compaction):${C.reset}  ${(pctInstant * 100).toFixed(1)}% of gaps`);
+  console.log();
+}
+
+main().catch(e => { console.error(e.message); process.exit(1); });

package/index.html

@@ -0,0 +1,243 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0">
+<title>cc-gap — Time between your Claude Code sessions</title>
+<meta name="description" content="How long does your AI rest between sessions? Drop your ~/.claude folder to see the gap distribution and discover your work rhythm.">
+<meta property="og:title" content="cc-gap — Session gap analyzer for Claude Code">
+<meta property="og:description" content="From 11-second compaction restarts to 2-day breaks — see how long Claude Code rests between sessions.">
+<meta property="og:url" content="https://yurukusa.github.io/cc-gap/">
+<meta name="twitter:card" content="summary">
+<meta name="twitter:site" content="@yurukusa_dev">
+<style>
+* { margin: 0; padding: 0; box-sizing: border-box; }
+:root {
+  --bg: #0d1117; --surface: #161b22; --border: #30363d;
+  --text: #e6edf3; --muted: #8b949e;
+  --purple: #bc8cff; --cyan: #58d8f0; --yellow: #f7c948; --orange: #ffa657;
+  --blue: #58a6ff; --green: #56d364;
+}
+body {
+  background: var(--bg); color: var(--text);
+  font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Consolas, monospace;
+  min-height: 100vh; display: flex; flex-direction: column;
+  align-items: center; padding: 2rem 1rem;
+}
+.header { text-align: center; margin-bottom: 2rem; }
+.header h1 { font-size: 1.8rem; font-weight: 700; color: var(--cyan); margin-bottom: 0.5rem; }
+.header p { color: var(--muted); font-size: 0.9rem; }
+.drop-zone {
+  width: 100%; max-width: 600px; border: 2px dashed var(--border);
+  border-radius: 12px; padding: 3rem 2rem; text-align: center;
+  cursor: pointer; transition: border-color 0.2s, background 0.2s;
+  margin-bottom: 2rem; background: var(--surface);
+}
+.drop-zone:hover, .drop-zone.drag-over { border-color: var(--cyan); background: #0f1f2a; }
+.drop-zone h2 { font-size: 1.1rem; margin-bottom: 0.75rem; }
+.drop-zone p { color: var(--muted); font-size: 0.85rem; line-height: 1.5; }
+.drop-zone .icon { font-size: 2.5rem; margin-bottom: 1rem; }
+.drop-zone input[type="file"] { display: none; }
+#results { width: 100%; max-width: 700px; display: none; }
+.meta { font-size: 0.8rem; color: var(--muted); margin-bottom: 1.5rem; text-align: center; }
+.card {
+  background: var(--surface); border: 1px solid var(--border);
+  border-radius: 8px; padding: 1.25rem; margin-bottom: 1.5rem;
+}
+.card-title { font-size: 0.7rem; color: var(--muted); text-transform: uppercase; letter-spacing: 0.08em; margin-bottom: 1rem; }
+.row {
+  display: flex; align-items: center; gap: 0.5rem;
+  margin-bottom: 0.3rem; font-size: 0.78rem;
+}
+.row-label { color: var(--muted); min-width: 5.5rem; font-family: Consolas, monospace; }
+.bar-wrap { flex: 1; height: 14px; background: #21262d; border-radius: 3px; overflow: hidden; }
+.bar-fill { height: 100%; border-radius: 3px; transition: width 0.4s ease; }
+.bar-fill.instant { background: var(--purple); }
+.bar-fill.quick   { background: var(--cyan); }
+.bar-fill.medium  { background: var(--yellow); }
+.bar-fill.long    { background: var(--orange); }
+.row-count { color: var(--muted); min-width: 5rem; text-align: right; font-family: Consolas, monospace; font-size: 0.75rem; }
+.score-card { text-align: center; }
+.cls-label { font-size: 1.5rem; font-weight: 700; color: var(--cyan); margin-bottom: 0.5rem; }
+.cls-desc  { font-size: 0.85rem; color: var(--muted); margin-bottom: 1rem; }
+.stats-grid {
+  display: grid; grid-template-columns: repeat(2, 1fr); gap: 0.75rem; margin-top: 1rem;
+}
+@media (min-width: 480px) { .stats-grid { grid-template-columns: repeat(4, 1fr); } }
+.stat { text-align: center; }
+.stat .num { font-size: 1.2rem; font-weight: 700; display: block; }
+.stat .lbl { font-size: 0.7rem; color: var(--muted); }
+.footer { margin-top: 2rem; text-align: center; font-size: 0.8rem; color: var(--muted); }
+.footer a { color: var(--blue); text-decoration: none; margin: 0 0.5rem; }
+.btn {
+  background: var(--cyan); color: #0d1117; border: none;
+  border-radius: 6px; padding: 0.6rem 1.5rem; font-size: 0.9rem;
+  font-weight: 600; cursor: pointer; margin-top: 1rem; font-family: inherit;
+}
+.btn:hover { opacity: 0.85; }
+</style>
+</head>
+<body>
+<div class="header">
+  <h1>cc-gap</h1>
+  <p>Time between your Claude Code sessions</p>
+</div>
+<div class="drop-zone" id="dropZone" onclick="document.getElementById('fi').click()">
+  <div class="icon">⏳</div>
+  <h2>Drop your .claude folder here</h2>
+  <p>Or click to select it.<br>Your data stays local — nothing is uploaded.</p>
+  <input type="file" id="fi" webkitdirectory multiple>
+  <button class="btn" onclick="event.stopPropagation(); document.getElementById('fi').click()">
+    Select ~/.claude folder
+  </button>
+</div>
+<div id="results">
+  <div class="meta" id="metaLine"></div>
+  <div class="card score-card" id="scoreCard"></div>
+  <div class="card">
+    <div class="card-title">Gap distribution (time between sessions)</div>
+    <div id="chart"></div>
+  </div>
+  <div class="footer">
+    <a href="https://github.com/yurukusa/cc-gap" target="_blank">GitHub</a> ·
+    <a href="https://yurukusa.github.io/cc-toolkit/" target="_blank">cc-toolkit (106 free tools)</a> ·
+    <span>Also: <code>npx cc-gap</code></span>
+  </div>
+</div>
+<div class="footer" id="footerMain">
+  <a href="https://github.com/yurukusa/cc-gap" target="_blank">GitHub</a> ·
+  <a href="https://yurukusa.github.io/cc-toolkit/" target="_blank">cc-toolkit</a> ·
+  <span>Part of 106 free tools for Claude Code</span>
+</div>
+<script>
+const dropZone = document.getElementById('dropZone');
+const fi = document.getElementById('fi');
+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(Array.from(e.dataTransfer.files)); });
+fi.addEventListener('change', e => processFiles(Array.from(e.target.files)));
+
+const BUCKETS = [
+  { label: '< 1 min',  min: 0,    max: 1,       cls: 'instant' },
+  { label: '1–5 min',  min: 1,    max: 5,       cls: 'quick' },
+  { label: '5–30 min', min: 5,    max: 30,      cls: 'quick' },
+  { label: '30m–2h',   min: 30,   max: 120,     cls: 'medium' },
+  { label: '2–8 hr',   min: 120,  max: 480,     cls: 'medium' },
+  { label: '8–24 hr',  min: 480,  max: 1440,    cls: 'long' },
+  { label: '1–2 days', min: 1440, max: 2880,    cls: 'long' },
+  { label: '2–7 days', min: 2880, max: 10080,   cls: 'long' },
+  { label: '7+ days',  min: 10080,max: Infinity, cls: 'long' },
+];
+
+function fmtGap(min) {
+  if (min < 1) return `${Math.round(min * 60)}s`;
+  if (min < 60) return `${Math.round(min)}m`;
+  const h = Math.floor(min / 60);
+  const m = Math.round(min % 60);
+  if (h < 24) return m ? `${h}h ${m}m` : `${h}h`;
+  const d = Math.floor(h / 24);
+  const rh = h % 24;
+  return rh ? `${d}d ${rh}h` : `${d}d`;
+}
+
+function median(arr) {
+  if (!arr.length) return 0;
+  const s = [...arr].sort((a, b) => a - b);
+  const m = Math.floor(s.length / 2);
+  return s.length % 2 ? s[m] : (s[m - 1] + s[m]) / 2;
+}
+
+function classify(med, pctInstant) {
+  if (pctInstant >= 0.5 || med < 2)
+    return { label: '⚡ Always On', desc: 'Your AI barely pauses. Instant restarts, continuous work.', color: 'var(--purple)' };
+  if (med < 30)
+    return { label: '🔄 Rapid Cycler', desc: 'Quick breaks between sessions. Fast iteration rhythm.', color: 'var(--cyan)' };
+  if (med < 240)
+    return { label: '⏸️ Steady Pauser', desc: 'Natural pauses between focused bursts.', color: 'var(--yellow)' };
+  if (med < 1440)
+    return { label: '🌙 Daily Worker', desc: 'Sessions cluster in work windows with overnight breaks.', color: 'var(--orange)' };
+  return { label: '📅 Weekend Coder', desc: 'Infrequent sessions with multi-day breaks between.', color: 'var(--orange)' };
+}
+
+async function processFiles(files) {
+  const sessionFiles = files.filter(f => {
+    const p = f.webkitRelativePath;
+    return p.endsWith('.jsonl') &&
+           p.includes('projects') &&
+           !p.includes('/subagents/');
+  });
+  if (!sessionFiles.length) {
+    alert('No session files found.\nSelect your .claude folder (not a subfolder).');
+    return;
+  }
+
+  const starts = [];
+  for (const f of sessionFiles) {
+    try {
+      const text = await f.slice(0, 4096).text();
+      for (const line of text.split('\n')) {
+        if (!line.trim()) continue;
+        try {
+          const d = JSON.parse(line);
+          if (d.timestamp) { starts.push(new Date(d.timestamp)); break; }
+        } catch {}
+      }
+    } catch {}
+  }
+
+  if (starts.length < 2) {
+    alert('Not enough sessions to compute gaps.');
+    return;
+  }
+
+  starts.sort((a, b) => a - b);
+  const gapsMin = [];
+  for (let i = 1; i < starts.length; i++) {
+    const g = (starts[i] - starts[i - 1]) / 60000;
+    if (g >= 0 && g < 365 * 24 * 60) gapsMin.push(g);
+  }
+
+  const sorted = [...gapsMin].sort((a, b) => a - b);
+  const total = sorted.length;
+  const med = median(sorted);
+  const avg = gapsMin.reduce((s, v) => s + v, 0) / total;
+  const maxVal = sorted[total - 1];
+  const p90 = sorted[Math.floor(total * 0.9)];
+  const pctInstant = sorted.filter(g => g < 1).length / total;
+
+  document.getElementById('metaLine').textContent = `${starts.length} sessions · ${total} gaps analyzed`;
+  dropZone.style.display = 'none';
+  document.getElementById('footerMain').style.display = 'none';
+  document.getElementById('results').style.display = 'block';
+
+  const bucketCounts = BUCKETS.map(b => ({
+    ...b,
+    count: sorted.filter(g => g >= b.min && g < b.max).length,
+  }));
+  const maxCount = Math.max(...bucketCounts.map(b => b.count), 1);
+
+  document.getElementById('chart').innerHTML = bucketCounts.map(b => {
+    const pct = (b.count / total * 100).toFixed(1);
+    const barPct = (b.count / maxCount * 100).toFixed(0);
+    return `<div class="row">
+      <span class="row-label">${b.label}</span>
+      <div class="bar-wrap"><div class="bar-fill ${b.cls}" style="width:${barPct}%"></div></div>
+      <span class="row-count">${b.count} (${pct}%)</span>
+    </div>`;
+  }).join('');
+
+  const cls = classify(med, pctInstant);
+  document.getElementById('scoreCard').innerHTML = `
+    <div class="card-title">Work rhythm</div>
+    <div class="cls-label" style="color:${cls.color}">${cls.label}</div>
+    <div class="cls-desc">${cls.desc}</div>
+    <div class="stats-grid">
+      <div class="stat"><span class="num" style="color:${cls.color}">${fmtGap(med)}</span><span class="lbl">median gap</span></div>
+      <div class="stat"><span class="num">${fmtGap(avg)}</span><span class="lbl">mean gap</span></div>
+      <div class="stat"><span class="num" style="color:var(--orange)">${fmtGap(maxVal)}</span><span class="lbl">longest gap</span></div>
+      <div class="stat"><span class="num">${(pctInstant * 100).toFixed(1)}%</span><span class="lbl">< 1 min (compact)</span></div>
+    </div>`;
+}
+</script>
+</body>
+</html>

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "cc-gap",
+  "version": "1.0.0",
+  "description": "How much time passes between your Claude Code sessions? Gap distribution and work rhythm analysis.",
+  "type": "module",
+  "bin": {
+    "cc-gap": "./cli.mjs"
+  },
+  "scripts": {
+    "start": "node cli.mjs"
+  },
+  "keywords": [
+    "claude-code",
+    "claude",
+    "ai",
+    "session",
+    "productivity",
+    "analytics",
+    "cli"
+  ],
+  "author": "yurukusa",
+  "license": "MIT",
+  "engines": {
+    "node": ">=18"
+  }
+}