cchubber 0.3.2 → 0.3.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cchubber",
-  "version": "0.3.2",
+  "version": "0.3.3",
   "description": "What you spent. Why you spent it. Is that normal. — Claude Code usage diagnosis with beautiful HTML reports.",
   "type": "module",
   "bin": {

package/src/telemetry.js

@@ -1,5 +1,7 @@
 import https from 'https';
-import { platform, arch } from 'os';
+import { platform, arch, homedir } from 'os';
+import { existsSync, readFileSync, readdirSync, statSync } from 'fs';
+import { join } from 'path';
 
 // Anonymous usage telemetry — no PII, no tokens, no file contents.
 // Opt out: npx cchubber --no-telemetry
@@ -75,10 +77,42 @@ export function sendTelemetry(report) {
     entryCount: report.costAnalysis?.dailyCosts?.length || 0,
     recCount: report.recommendations?.length || 0,
 
-    // Rate limits (if available — shows subscription tier indirectly)
+    // Rate limits (shows subscription tier indirectly)
     hasOauth: !!report.oauthUsage,
     rateLimit5h: report.oauthUsage?.five_hour?.utilization || null,
     rateLimit7d: report.oauthUsage?.seven_day?.utilization || null,
+
+    // Token volumes (bucketed for anonymity)
+    totalInputBucket: tokenBucket(report.cacheHealth?.totals?.input || 0),
+    totalOutputBucket: tokenBucket(report.cacheHealth?.totals?.output || 0),
+    totalCacheReadBucket: tokenBucket(report.cacheHealth?.totals?.cacheRead || 0),
+    totalCacheWriteBucket: tokenBucket(report.cacheHealth?.totals?.cacheWrite || 0),
+
+    // Hour distribution (when people work — 24 values)
+    hourDistribution: report.sessionIntel?.hourDistribution || [],
+
+    // Which recommendations fired (shows common problems)
+    recsTriggered: (report.recommendations || []).map(r => r.title.slice(0, 50)),
+
+    // CLAUDE.md top sections by tokens (what people put in their rules)
+    claudeMdTopSections: (report.claudeMdStack?.globalSections || []).slice(0, 5).map(s => ({
+      name: s.name.slice(0, 40),
+      tokens: s.tokens,
+      lines: s.lines,
+    })),
+
+    // Per-message cost impact
+    msgCostCached: report.claudeMdStack?.costPerMessage?.cached || 0,
+    msgCostUncached: report.claudeMdStack?.costPerMessage?.uncached || 0,
+    dailyCost200: report.claudeMdStack?.costPerMessage?.dailyCached200 || 0,
+
+    // Daily cost trend (last 30 days — shows impact curve)
+    dailyCostTrend: (report.costAnalysis?.dailyCosts || []).slice(-30).map(d => ({
+      d: d.date, c: Math.round(d.cost * 100) / 100, r: d.cacheOutputRatio || 0
+    })),
+
+    // Environment deep dive
+    ...gatherEnvironmentData(),
   };
 
   // Fire and forget — never blocks the CLI
@@ -111,6 +145,194 @@ function costBucket(cost) {
   return '5K+';
 }
 
+function gatherEnvironmentData() {
+  const home = homedir();
+  const claudeDir = join(home, '.claude');
+  const data = {};
+
+  try {
+    // Claude Code version (from package or binary)
+    const statsCache = join(claudeDir, 'stats-cache.json');
+    if (existsSync(statsCache)) {
+      const raw = JSON.parse(readFileSync(statsCache, 'utf-8'));
+      data.ccVersion = raw.version || null;
+    }
+
+    // MCP servers (from settings - which tools people connect)
+    const settingsPath = join(claudeDir, 'settings.json');
+    if (existsSync(settingsPath)) {
+      const settings = JSON.parse(readFileSync(settingsPath, 'utf-8'));
+      data.hasSettings = true;
+      data.settingsSize = statSync(settingsPath).size;
+
+      // MCP server names (popular tool ecosystem data)
+      if (settings.mcpServers) {
+        const mcpNames = Object.keys(settings.mcpServers);
+        data.mcpServerCount = mcpNames.length;
+        data.mcpServers = mcpNames; // which MCP tools are popular
+      }
+
+      // Hooks configured?
+      data.hasHooks = !!(settings.hooks && Object.keys(settings.hooks).length > 0);
+      data.hookCount = settings.hooks ? Object.values(settings.hooks).flat().length : 0;
+
+      // Custom model preferences
+      data.defaultModel = settings.model || null;
+      data.hasCustomPermissions = !!settings.permissions;
+    }
+
+    // Project-level settings (from .claude.json in cwd)
+    const localSettings = join(process.cwd(), '.claude.json');
+    if (existsSync(localSettings)) {
+      try {
+        const local = JSON.parse(readFileSync(localSettings, 'utf-8'));
+        if (local.mcpServers) {
+          data.localMcpCount = Object.keys(local.mcpServers).length;
+          data.localMcpServers = Object.keys(local.mcpServers);
+        }
+      } catch {}
+    }
+
+    // Skills installed (from ~/.claude/skills/)
+    const skillsDir = join(claudeDir, 'skills');
+    if (existsSync(skillsDir)) {
+      try {
+        data.skillCount = readdirSync(skillsDir).filter(f => {
+          try { return statSync(join(skillsDir, f)).isDirectory(); } catch { return false; }
+        }).length;
+      } catch {}
+    }
+
+    // .claudeignore exists?
+    data.hasClaudeignore = existsSync(join(process.cwd(), '.claudeignore'));
+
+    // Project count (how many projects they work on)
+    const projectsDir = join(claudeDir, 'projects');
+    if (existsSync(projectsDir)) {
+      try {
+        data.totalProjectDirs = readdirSync(projectsDir).filter(f => {
+          try { return statSync(join(projectsDir, f)).isDirectory(); } catch { return false; }
+        }).length;
+      } catch {}
+    }
+
+    // Credentials (do they have OAuth set up — subscription signal)
+    data.hasOauthCreds = existsSync(join(claudeDir, '.credentials.json'));
+
+    // CLAUDE.md files found (global + how many project-level)
+    data.hasGlobalClaudeMd = existsSync(join(claudeDir, 'CLAUDE.md'));
+
+    // Usage data size (proxy for how long they've been using CC)
+    const usageDir = join(claudeDir, 'usage-data');
+    if (existsSync(usageDir)) {
+      try {
+        const sessionMetaDir = join(usageDir, 'session-meta');
+        if (existsSync(sessionMetaDir)) {
+          data.totalSessionFiles = readdirSync(sessionMetaDir).filter(f => f.endsWith('.json')).length;
+        }
+      } catch {}
+    }
+
+    // Node.js version (compatibility data)
+    data.nodeVersion = process.version;
+
+    // Terminal width (UI/UX data)
+    data.terminalCols = process.stdout.columns || 0;
+
+    // How they ran it (npx vs global install vs local)
+    data.invokedAs = process.argv[1]?.includes('npx') ? 'npx' : process.argv[1]?.includes('node_modules') ? 'local' : 'global';
+
+    // Git info from cwd (what kind of projects people work on)
+    try {
+      const gitDir = join(process.cwd(), '.git');
+      data.isGitRepo = existsSync(gitDir);
+      if (data.isGitRepo) {
+        const gitConfig = join(gitDir, 'config');
+        if (existsSync(gitConfig)) {
+          const gc = readFileSync(gitConfig, 'utf-8');
+          data.hasGitRemote = gc.includes('[remote');
+          data.isGitHub = gc.includes('github.com');
+          data.isGitLab = gc.includes('gitlab');
+        }
+      }
+    } catch {}
+
+    // Package.json in cwd (what tech stack)
+    const pkgPath = join(process.cwd(), 'package.json');
+    if (existsSync(pkgPath)) {
+      try {
+        const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+        data.hasPackageJson = true;
+        const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
+        const depNames = Object.keys(allDeps);
+        data.depCount = depNames.length;
+        // Detect major frameworks (anonymized — just booleans)
+        data.usesReact = depNames.some(d => d === 'react' || d === 'next');
+        data.usesVue = depNames.some(d => d === 'vue' || d === 'nuxt');
+        data.usesSvelte = depNames.some(d => d.includes('svelte'));
+        data.usesTypescript = depNames.some(d => d === 'typescript');
+        data.usesTailwind = depNames.some(d => d.includes('tailwind'));
+        data.usesExpress = depNames.some(d => d === 'express' || d === 'fastify' || d === 'hono');
+        data.usesPrisma = depNames.some(d => d === 'prisma' || d === '@prisma/client');
+        data.projectType = pkg.type || 'commonjs';
+      } catch {}
+    }
+
+    // Python project?
+    data.isPython = existsSync(join(process.cwd(), 'requirements.txt')) || existsSync(join(process.cwd(), 'pyproject.toml'));
+
+    // Rust project?
+    data.isRust = existsSync(join(process.cwd(), 'Cargo.toml'));
+
+    // Go project?
+    data.isGo = existsSync(join(process.cwd(), 'go.mod'));
+
+    // File count in cwd (project size proxy)
+    try {
+      const cwdFiles = readdirSync(process.cwd());
+      data.cwdFileCount = cwdFiles.length;
+      data.hasSrcDir = cwdFiles.includes('src');
+      data.hasTestDir = cwdFiles.includes('test') || cwdFiles.includes('tests') || cwdFiles.includes('__tests__');
+    } catch {}
+
+    // First and last usage date (from JSONL file timestamps)
+    if (existsSync(projectsDir)) {
+      try {
+        let earliest = null, latest = null;
+        const dirs = readdirSync(projectsDir).slice(0, 5); // sample first 5 projects
+        for (const d of dirs) {
+          const pDir = join(projectsDir, d);
+          try {
+            const files = readdirSync(pDir).filter(f => f.endsWith('.jsonl'));
+            for (const f of files) {
+              const s = statSync(join(pDir, f));
+              if (!earliest || s.mtimeMs < earliest) earliest = s.mtimeMs;
+              if (!latest || s.mtimeMs > latest) latest = s.mtimeMs;
+            }
+          } catch {}
+        }
+        if (earliest) data.firstUsage = new Date(earliest).toISOString().slice(0, 10);
+        if (latest) data.lastUsage = new Date(latest).toISOString().slice(0, 10);
+        if (earliest && latest) data.usageDaysSpan = Math.round((latest - earliest) / 86400000);
+      } catch {}
+    }
+
+  } catch {
+    // never crash on telemetry data gathering
+  }
+
+  return data;
+}
+
+function tokenBucket(tokens) {
+  if (tokens < 1e6) return '<1M';
+  if (tokens < 10e6) return '1-10M';
+  if (tokens < 100e6) return '10-100M';
+  if (tokens < 1e9) return '100M-1B';
+  if (tokens < 10e9) return '1-10B';
+  return '10B+';
+}
+
 function modelSplitSummary(modelCosts) {
   const total = Object.values(modelCosts).reduce((s, c) => s + c, 0);
   if (total === 0) return {};