cc-depth 1.0.0

package/README.md

@@ -0,0 +1,78 @@
+# cc-depth
+
+How many turns per Claude Code session?
+
+Shows the distribution of conversation depth — how many back-and-forth exchanges happen in each session.
+
+## Usage
+
+```bash
+npx cc-depth
+```
+
+```
+cc-depth — Turns per session
+
+  1        ███░░░░░░░░░░░░░░░░░░░░░░░░░░░    18  (  3%)
+  2–5      ██████████████████░░░░░░░░░░░░   104  ( 20%)
+  6–15     █████████████░░░░░░░░░░░░░░░░░    75  ( 14%)
+  16–30    ████████░░░░░░░░░░░░░░░░░░░░░░    48  (  9%)
+  31–60    █████████░░░░░░░░░░░░░░░░░░░░░    54  ( 10%)
+  61–100   █████████░░░░░░░░░░░░░░░░░░░░░    53  ( 10%)
+  101+     ██████████████████████████████   174  ( 33%)
+
+─────────────────────────────────────────────────────────
+  Median:  38 turns/session
+  Mean:    263 turns/session
+  Peak:    14,169 turns
+  Style:   🔄 Loop Runner  (extended sessions or autonomous loop)
+
+  Analyzed 526 sessions
+```
+
+## Style Classifications
+
+| Style | Median | What it means |
+|-------|--------|---------------|
+| 💬 Quick Prompter | ≤ 3 turns | One-shot queries, fast iterations |
+| ✅ Task Completer | 4–10 turns | Focused task sessions |
+| 🤝 Collaborative Coder | 11–30 turns | Back-and-forth workflow |
+| 🔄 Loop Runner | > 30 turns | Extended sessions or autonomous loop |
+
+## Options
+
+```bash
+npx cc-depth                        # All sessions
+npx cc-depth --json                 # JSON output
+npx cc-depth --projects=cc-loop     # Filter by project name
+npx cc-depth --help                 # Show help
+```
+
+## Browser Version
+
+→ **[yurukusa.github.io/cc-depth](https://yurukusa.github.io/cc-depth/)**
+
+Drag in your `~/.claude` folder. Runs entirely locally.
+
+## What counts as a "turn"?
+
+Each user message in a session counts as one turn. This includes:
+- Your direct prompts and questions
+- Continuation messages (in autonomous setups like cc-loop)
+- System-level messages
+
+For interactive users, a typical session is 2–30 turns. Autonomous loop setups show much higher counts.
+
+## Part of cc-toolkit
+
+cc-depth is tool #49 in [cc-toolkit](https://yurukusa.github.io/cc-toolkit/) — 50 free tools for Claude Code users.
+
+Related:
+- [cc-session-length](https://github.com/yurukusa/cc-session-length) — Duration distribution
+- [cc-momentum](https://github.com/yurukusa/cc-momentum) — Week-by-week session trend
+- [cc-gap](https://github.com/yurukusa/cc-gap) — Time between sessions
+
+---
+
+**GitHub**: [yurukusa/cc-depth](https://github.com/yurukusa/cc-depth)
+**Try it**: `npx cc-depth`

package/cli.mjs

@@ -0,0 +1,196 @@
+#!/usr/bin/env node
+/**
+ * cc-depth — How many turns per Claude Code session?
+ * Shows the distribution of conversation depth across your sessions.
+ */
+
+import { readFileSync, readdirSync, statSync } from 'fs';
+import { join, resolve } 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');
+const projectsFlag = args.find(a => a.startsWith('--projects='));
+const projectsFilter = projectsFlag ? projectsFlag.split('=')[1] : null;
+
+if (showHelp) {
+  console.log(`cc-depth — Conversation depth per Claude Code session
+
+Usage:
+  npx cc-depth               # All sessions
+  npx cc-depth --json        # JSON output
+  npx cc-depth --projects=cc-loop  # Filter by project name
+
+Shows how many turns (user messages) occur per session.
+`);
+  process.exit(0);
+}
+
+// Find ~/.claude/projects directory
+const claudeDir = join(homedir(), '.claude', 'projects');
+
+function scanProjects(dir) {
+  const sessions = [];
+  let projectDirs;
+  try {
+    projectDirs = readdirSync(dir);
+  } catch {
+    return sessions;
+  }
+
+  for (const projDir of projectDirs) {
+    if (projectsFilter && !projDir.includes(projectsFilter)) continue;
+    const projPath = join(dir, projDir);
+    let entries;
+    try {
+      entries = readdirSync(projPath);
+    } catch {
+      continue;
+    }
+
+    for (const entry of entries) {
+      if (!entry.endsWith('.jsonl')) continue;
+      // Skip subagent files
+      if (projPath.includes('/subagents/') || entry.includes('subagent')) continue;
+
+      const filePath = join(projPath, entry);
+      // Check subdirs (subagents)
+      try {
+        const stat = statSync(filePath);
+        if (!stat.isFile()) continue;
+      } catch {
+        continue;
+      }
+
+      // Count "type":"user" occurrences in file
+      let content;
+      try {
+        content = readFileSync(filePath, 'utf8');
+      } catch {
+        continue;
+      }
+
+      // Fast string counting — "type":"user" at top level
+      // Each line is one JSON object; we count lines containing this pattern
+      let turns = 0;
+      let firstTimestamp = null;
+      const lines = content.split('\n');
+      for (const line of lines) {
+        if (!line.trim()) continue;
+        // Count user turns
+        if (line.includes('"type":"user"')) {
+          turns++;
+        }
+        // Grab first timestamp for date info
+        if (!firstTimestamp && line.includes('"timestamp"')) {
+          const m = line.match(/"timestamp":"([^"]+)"/);
+          if (m) firstTimestamp = m[1];
+        }
+      }
+
+      if (turns > 0) {
+        sessions.push({
+          id: entry.replace('.jsonl', ''),
+          project: projDir,
+          turns,
+          date: firstTimestamp ? new Date(firstTimestamp) : null,
+        });
+      }
+    }
+  }
+
+  return sessions;
+}
+
+const sessions = scanProjects(claudeDir);
+
+if (sessions.length === 0) {
+  console.error('No session files found. Make sure ~/.claude/projects/ exists.');
+  process.exit(1);
+}
+
+// Sort by turns ascending for stats
+const turnCounts = sessions.map(s => s.turns).sort((a, b) => a - b);
+const n = turnCounts.length;
+const total = turnCounts.reduce((a, b) => a + b, 0);
+const median = turnCounts[Math.floor(n / 2)];
+const mean = total / n;
+const max = turnCounts[n - 1];
+const min = turnCounts[0];
+
+// Peak session
+const peakSession = sessions.reduce((a, b) => a.turns > b.turns ? a : b);
+
+// Distribution buckets
+const buckets = [
+  { label: '1',      min: 1,  max: 1,   count: 0 },
+  { label: '2–5',   min: 2,  max: 5,   count: 0 },
+  { label: '6–15',  min: 6,  max: 15,  count: 0 },
+  { label: '16–30', min: 16, max: 30,  count: 0 },
+  { label: '31–60', min: 31, max: 60,  count: 0 },
+  { label: '61–100',min: 61, max: 100, count: 0 },
+  { label: '101+',  min: 101, max: Infinity, count: 0 },
+];
+
+for (const t of turnCounts) {
+  for (const b of buckets) {
+    if (t >= b.min && t <= b.max) {
+      b.count++;
+      break;
+    }
+  }
+}
+
+// Classification
+function classify(median) {
+  if (median <= 3)  return { label: '💬 Quick Prompter',     desc: 'one-shot queries, fast iterations' };
+  if (median <= 10) return { label: '✅ Task Completer',      desc: 'focused task sessions' };
+  if (median <= 30) return { label: '🤝 Collaborative Coder', desc: 'back-and-forth workflow' };
+  return                   { label: '🔄 Loop Runner',         desc: 'extended sessions or autonomous loop' };
+}
+
+const style = classify(median);
+
+if (jsonMode) {
+  console.log(JSON.stringify({
+    sessions: n,
+    median_turns: median,
+    mean_turns: Math.round(mean),
+    min_turns: min,
+    max_turns: max,
+    style: style.label,
+    buckets: buckets.map(b => ({ range: b.label, count: b.count, pct: Math.round(b.count / n * 100) })),
+    peak: { id: peakSession.id, turns: peakSession.turns, date: peakSession.date },
+  }, null, 2));
+  process.exit(0);
+}
+
+// Bar chart rendering
+const BAR_WIDTH = 30;
+const maxCount = Math.max(...buckets.map(b => b.count));
+
+function bar(count) {
+  const filled = maxCount > 0 ? Math.round((count / maxCount) * BAR_WIDTH) : 0;
+  return '█'.repeat(filled) + '░'.repeat(BAR_WIDTH - filled);
+}
+
+function rpad(str, len) {
+  return str + ' '.repeat(Math.max(0, len - str.length));
+}
+
+console.log('cc-depth — Turns per session\n');
+
+for (const b of buckets) {
+  const label = rpad(b.label, 7);
+  const countStr = String(b.count).padStart(4);
+  const pct = (b.count / n * 100).toFixed(0).padStart(3);
+  console.log(`  ${label}  ${bar(b.count)}  ${countStr}  (${pct}%)`);
+}
+
+console.log('\n' + '─'.repeat(57));
+console.log(`  Median:  ${median} turns/session`);
+console.log(`  Mean:    ${Math.round(mean)} turns/session`);
+console.log(`  Peak:    ${max.toLocaleString()} turns`);
+console.log(`  Style:   ${style.label}  (${style.desc})`);
+console.log(`\n  Analyzed ${n} sessions`);

package/index.html

@@ -0,0 +1,293 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0">
+<title>cc-depth — Conversation depth per session</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: #f0883e;
+    margin-bottom: 6px;
+    letter-spacing: -0.5px;
+  }
+  .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: #f0883e;
+    background: rgba(240,136,62,0.05);
+  }
+  .drop-icon { font-size: 2.5rem; margin-bottom: 12px; }
+  .drop-text { color: #8b949e; font-size: 0.875rem; line-height: 1.6; }
+  .drop-text strong { color: #c9d1d9; }
+  #file-input { display: none; }
+
+  .result { display: none; max-width: 600px; 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: 16px;
+    margin-bottom: 16px;
+  }
+  .stat-item { text-align: center; }
+  .stat-val { font-size: 1.6rem; color: #f0883e; font-weight: 700; }
+  .stat-lbl { font-size: 0.75rem; color: #8b949e; margin-top: 2px; }
+
+  .style-badge {
+    text-align: center;
+    padding: 10px;
+    background: rgba(240,136,62,0.1);
+    border: 1px solid rgba(240,136,62,0.3);
+    border-radius: 6px;
+    font-size: 1rem;
+    color: #f0883e;
+  }
+  .style-desc { font-size: 0.8rem; color: #8b949e; margin-top: 4px; }
+
+  .bar-chart { font-size: 0.8rem; }
+  .bar-row {
+    display: flex;
+    align-items: center;
+    gap: 10px;
+    margin-bottom: 6px;
+  }
+  .bar-label { width: 56px; text-align: right; color: #8b949e; flex-shrink: 0; }
+  .bar-track {
+    flex: 1;
+    height: 14px;
+    background: #21262d;
+    border-radius: 3px;
+    overflow: hidden;
+  }
+  .bar-fill {
+    height: 100%;
+    background: #f0883e;
+    border-radius: 3px;
+    transition: width 0.6s ease;
+  }
+  .bar-count { width: 64px; color: #c9d1d9; text-align: right; flex-shrink: 0; }
+
+  .footer { color: #8b949e; font-size: 0.75rem; text-align: center; margin-top: 12px; }
+  .footer a { color: #f0883e; text-decoration: none; }
+  .footer a:hover { text-decoration: underline; }
+
+  .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: #f0883e; color: #f0883e; }
+</style>
+</head>
+<body>
+
+<h1>📊 cc-depth</h1>
+<p class="subtitle">Conversation depth per Claude Code session</p>
+
+<div class="drop-zone" id="drop-zone">
+  <div class="drop-icon">📁</div>
+  <div class="drop-text">
+    <strong>Drop your ~/.claude folder here</strong><br>
+    or click to select<br>
+    <br>
+    Reads session files locally.<br>
+    Nothing is uploaded.
+  </div>
+  <input type="file" id="file-input" webkitdirectory multiple accept=".jsonl">
+</div>
+
+<div class="result" id="result">
+  <div class="card">
+    <div class="card-title">Session Depth Summary</div>
+    <div class="stats-grid">
+      <div class="stat-item">
+        <div class="stat-val" id="stat-median">—</div>
+        <div class="stat-lbl">median turns</div>
+      </div>
+      <div class="stat-item">
+        <div class="stat-val" id="stat-mean">—</div>
+        <div class="stat-lbl">mean turns</div>
+      </div>
+      <div class="stat-item">
+        <div class="stat-val" id="stat-max">—</div>
+        <div class="stat-lbl">peak turns</div>
+      </div>
+      <div class="stat-item">
+        <div class="stat-val" id="stat-sessions">—</div>
+        <div class="stat-lbl">sessions</div>
+      </div>
+    </div>
+    <div class="style-badge" id="stat-style">—</div>
+    <div class="style-desc" id="stat-desc"></div>
+  </div>
+
+  <div class="card">
+    <div class="card-title">Distribution</div>
+    <div class="bar-chart" id="bar-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-depth" target="_blank">cc-depth</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 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');
+  dropZone.style.display = '';
+  fileInput.value = '';
+});
+
+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 === 0) {
+    alert('No session files found. Drop your ~/.claude folder.');
+    return;
+  }
+
+  dropZone.style.display = 'none';
+
+  const sessions = [];
+  const BATCH = 50;
+  for (let i = 0; i < jsonlFiles.length; i += BATCH) {
+    const batch = jsonlFiles.slice(i, i + BATCH);
+    await Promise.all(batch.map(async f => {
+      try {
+        const text = await f.text();
+        let turns = 0;
+        for (const line of text.split('\n')) {
+          if (line.includes('"type":"user"')) turns++;
+        }
+        if (turns > 0) sessions.push(turns);
+      } catch {}
+    }));
+  }
+
+  if (sessions.length === 0) {
+    alert('Could not parse session files.');
+    return;
+  }
+
+  sessions.sort((a, b) => a - b);
+  const n = sessions.length;
+  const median = sessions[Math.floor(n / 2)];
+  const mean = Math.round(sessions.reduce((a, b) => a + b, 0) / n);
+  const max = sessions[n - 1];
+
+  const classify = m => {
+    if (m <= 3)  return { label: '💬 Quick Prompter',     desc: 'one-shot queries, fast iterations' };
+    if (m <= 10) return { label: '✅ Task Completer',      desc: 'focused task sessions' };
+    if (m <= 30) return { label: '🤝 Collaborative Coder', desc: 'back-and-forth workflow' };
+    return               { label: '🔄 Loop Runner',         desc: 'extended sessions or autonomous loop' };
+  };
+  const style = classify(median);
+
+  document.getElementById('stat-median').textContent = median;
+  document.getElementById('stat-mean').textContent = mean.toLocaleString();
+  document.getElementById('stat-max').textContent = max.toLocaleString();
+  document.getElementById('stat-sessions').textContent = n;
+  document.getElementById('stat-style').textContent = style.label;
+  document.getElementById('stat-desc').textContent = style.desc;
+
+  const buckets = [
+    { label: '1',      min: 1,  max: 1 },
+    { label: '2–5',   min: 2,  max: 5 },
+    { label: '6–15',  min: 6,  max: 15 },
+    { label: '16–30', min: 16, max: 30 },
+    { label: '31–60', min: 31, max: 60 },
+    { label: '61–100',min: 61, max: 100 },
+    { label: '101+',  min: 101, max: Infinity },
+  ].map(b => ({
+    ...b,
+    count: sessions.filter(t => t >= b.min && t <= b.max).length,
+  }));
+
+  const maxCount = Math.max(...buckets.map(b => b.count));
+  const chart = document.getElementById('bar-chart');
+  chart.innerHTML = buckets.map(b => `
+    <div class="bar-row">
+      <div class="bar-label">${b.label}</div>
+      <div class="bar-track">
+        <div class="bar-fill" style="width:${maxCount > 0 ? (b.count / maxCount * 100) : 0}%"></div>
+      </div>
+      <div class="bar-count">${b.count} (${Math.round(b.count / n * 100)}%)</div>
+    </div>
+  `).join('');
+
+  resultEl.classList.add('visible');
+}
+</script>
+</body>
+</html>

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "cc-depth",
+  "version": "1.0.0",
+  "description": "How many turns per Claude Code session? Distribution of conversation depth.",
+  "type": "module",
+  "bin": {
+    "cc-depth": "./cli.mjs"
+  },
+  "scripts": {
+    "start": "node cli.mjs"
+  },
+  "keywords": [
+    "claude",
+    "claude-code",
+    "ai",
+    "developer-tools",
+    "analytics",
+    "productivity"
+  ],
+  "author": "yurukusa",
+  "license": "MIT",
+  "engines": {
+    "node": ">=18"
+  }
+}