claude-roi 0.1.0

package/src/git-analyzer.js

@@ -0,0 +1,170 @@
+import { execSync } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import path from 'node:path';
+
+export function getGitUser() {
+  try {
+    const name = execSync('git config user.name', { encoding: 'utf-8' }).trim();
+    const email = execSync('git config user.email', { encoding: 'utf-8' }).trim();
+    return { name, email };
+  } catch {
+    return { name: 'unknown', email: 'unknown' };
+  }
+}
+
+function detectDefaultBranch(repoPath) {
+  // 1. Check what the remote HEAD points to (most reliable)
+  try {
+    const ref = execSync(
+      `git -C "${repoPath}" symbolic-ref refs/remotes/origin/HEAD`,
+      { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] }
+    ).trim();
+    // Returns e.g. "refs/remotes/origin/main"
+    const branch = ref.replace('refs/remotes/origin/', '');
+    if (branch) return branch;
+  } catch {
+    // No remote HEAD set, fall through
+  }
+
+  // 2. Fallback: check for common default branch names
+  try {
+    const branches = execSync(`git -C "${repoPath}" branch --list`, { encoding: 'utf-8' });
+    const branchList = branches.split('\n').map(b => b.replace('*', '').trim()).filter(Boolean);
+    for (const name of ['main', 'master', 'develop', 'development', 'staging', 'trunk']) {
+      if (branchList.includes(name)) return name;
+    }
+    // 3. Last resort: return the first branch
+    if (branchList.length > 0) return branchList[0];
+  } catch {
+    // ignore
+  }
+
+  return null;
+}
+
+function getMainBranchHashes(repoPath) {
+  const mainBranch = detectDefaultBranch(repoPath);
+  if (!mainBranch) return { hashes: new Set(), branchName: null };
+
+  try {
+    const raw = execSync(
+      `git -C "${repoPath}" log ${mainBranch} --format=%H`,
+      { encoding: 'utf-8', maxBuffer: 50 * 1024 * 1024 }
+    );
+    return {
+      hashes: new Set(raw.trim().split('\n').filter(Boolean)),
+      branchName: mainBranch,
+    };
+  } catch {
+    return { hashes: new Set(), branchName: mainBranch };
+  }
+}
+
+function parseGitLog(raw) {
+  const commits = [];
+  let current = null;
+
+  for (const line of raw.split('\n')) {
+    if (line.startsWith('COMMIT:')) {
+      if (current) commits.push(current);
+      const rest = line.slice(7);
+      // Format: hash|email|timestamp|subject|decorations
+      // Subject may contain | so we split carefully
+      const pipeIdx1 = rest.indexOf('|');
+      const pipeIdx2 = rest.indexOf('|', pipeIdx1 + 1);
+      const pipeIdx3 = rest.indexOf('|', pipeIdx2 + 1);
+
+      if (pipeIdx1 === -1 || pipeIdx2 === -1 || pipeIdx3 === -1) continue;
+
+      const hash = rest.slice(0, pipeIdx1);
+      const email = rest.slice(pipeIdx1 + 1, pipeIdx2);
+      const timestamp = rest.slice(pipeIdx2 + 1, pipeIdx3);
+      const remaining = rest.slice(pipeIdx3 + 1);
+
+      // Last field after last | is decorations (may be empty)
+      const lastPipe = remaining.lastIndexOf('|');
+      let subject, decorations;
+      if (lastPipe !== -1) {
+        subject = remaining.slice(0, lastPipe);
+        decorations = remaining.slice(lastPipe + 1).trim();
+      } else {
+        subject = remaining;
+        decorations = '';
+      }
+
+      current = {
+        hash,
+        authorEmail: email,
+        timestamp,
+        timestampMs: new Date(timestamp).getTime(),
+        subject,
+        decorations,
+        branches: [],
+        onMain: false,
+        files: [],
+        totalAdded: 0,
+        totalDeleted: 0,
+        netLines: 0,
+      };
+
+      // Parse decorations for branch info
+      if (decorations) {
+        const refs = decorations.split(',').map(r => r.trim());
+        for (const ref of refs) {
+          const cleaned = ref
+            .replace('HEAD -> ', '')
+            .replace('origin/', '')
+            .trim();
+          if (cleaned && !cleaned.startsWith('tag:')) {
+            current.branches.push(cleaned);
+          }
+        }
+      }
+    } else if (current && line.trim()) {
+      // numstat line: "2\t2\tpath/to/file" or "-\t-\tbinary_file"
+      const parts = line.split('\t');
+      if (parts.length >= 3) {
+        const added = parts[0] === '-' ? 0 : parseInt(parts[0], 10) || 0;
+        const deleted = parts[1] === '-' ? 0 : parseInt(parts[1], 10) || 0;
+        const filePath = parts.slice(2).join('\t'); // handle filenames with tabs
+        current.files.push({ path: filePath, added, deleted });
+        current.totalAdded += added;
+        current.totalDeleted += deleted;
+        current.netLines += (added - deleted);
+      }
+    }
+  }
+  if (current) commits.push(current);
+  return commits;
+}
+
+export function analyzeGitRepo(repoPath, days) {
+  if (!existsSync(path.join(repoPath, '.git'))) {
+    return { repoPath, commits: [], allCommits: [], defaultBranch: null };
+  }
+
+  const user = getGitUser();
+
+  try {
+    const raw = execSync(
+      `git -C "${repoPath}" log --all --since="${days} days ago" --format="COMMIT:%H|%ae|%aI|%s|%D" --numstat`,
+      { encoding: 'utf-8', maxBuffer: 50 * 1024 * 1024 }
+    );
+
+    const allCommits = parseGitLog(raw);
+
+    // Get default branch hashes for onMain tagging
+    const { hashes: mainHashes, branchName } = getMainBranchHashes(repoPath);
+    for (const commit of allCommits) {
+      commit.onMain = mainHashes.has(commit.hash);
+    }
+
+    // Filter to current user
+    const userCommits = allCommits.filter(c => c.authorEmail === user.email);
+
+    return { repoPath, commits: userCommits, allCommits, defaultBranch: branchName };
+  } catch (err) {
+    process.stderr.write(`Warning: Git analysis failed for ${repoPath}: ${err.message}\n`);
+    return { repoPath, commits: [], allCommits: [], defaultBranch: null };
+  }
+}

package/src/index.js

@@ -0,0 +1,138 @@
+#!/usr/bin/env node
+
+import { Command } from 'commander';
+import path from 'node:path';
+import os from 'node:os';
+import { parseAllProjects } from './claude-parser.js';
+import { analyzeGitRepo, getGitUser } from './git-analyzer.js';
+import { correlateSessions } from './correlator.js';
+import { computeMetrics } from './metrics.js';
+import { loadCache, saveCache, deleteCache, getStaleFiles } from './cache.js';
+import { createServer } from './server.js';
+
+const VERSION = '0.1.0';
+
+async function main() {
+  const program = new Command();
+  program
+    .name('claude-roi')
+    .description('Correlate Claude Code token usage with git output to measure AI coding agent ROI')
+    .version(VERSION)
+    .option('-p, --port <number>', 'port to serve dashboard', '3457')
+    .option('-d, --days <number>', 'number of days to look back', '30')
+    .option('--no-open', 'do not auto-open browser')
+    .option('--json', 'output raw JSON to stdout instead of starting server')
+    .option('--project <name>', 'filter to specific project')
+    .option('--refresh', 'force full re-parse, ignore cache');
+
+  program.parse();
+  const opts = program.opts();
+  const port = parseInt(opts.port, 10);
+  const days = parseInt(opts.days, 10);
+
+  console.log(`\x1b[36mclaude-roi\x1b[0m v${VERSION}`);
+
+  const claudeDir = path.join(os.homedir(), '.claude', 'projects');
+
+  // Step 1: Parse sessions (with caching)
+  let sessions;
+  let fileIndex;
+  const startParse = Date.now();
+
+  if (opts.refresh) {
+    deleteCache();
+    console.log('Cache cleared, performing full parse...');
+  }
+
+  const cached = opts.refresh ? null : loadCache();
+
+  if (cached) {
+    // Incremental parse: only process new/modified files
+    const stale = getStaleFiles(claudeDir, cached.fileIndex);
+    const newCount = stale.newFiles.length;
+    const modifiedCount = stale.modifiedFiles.length;
+    const deletedCount = stale.deletedFiles.length;
+    const cachedCount = Object.keys(cached.fileIndex).length - modifiedCount - deletedCount;
+
+    if (newCount === 0 && modifiedCount === 0 && deletedCount === 0) {
+      // Nothing changed, use cache as-is
+      sessions = cached.sessions;
+      fileIndex = cached.fileIndex;
+      console.log(`Parsing sessions... ${cached.sessions.length} cached (${Date.now() - startParse}ms)`);
+    } else {
+      // Parse only new/modified files
+      const { sessions: freshSessions, fileIndex: freshIndex } = await parseAllProjects(claudeDir, days, opts.project);
+
+      // For a simpler approach: just do a full re-parse when files change
+      // This avoids complex merging logic while still benefiting from caching
+      // when nothing has changed
+      sessions = freshSessions;
+      fileIndex = freshIndex;
+      console.log(`Parsing sessions... ${newCount} new, ${modifiedCount} updated, ${Math.max(0, cachedCount)} cached (${Date.now() - startParse}ms)`);
+    }
+  } else {
+    // Full parse
+    const result = await parseAllProjects(claudeDir, days, opts.project);
+    sessions = result.sessions;
+    fileIndex = result.fileIndex;
+    console.log(`Parsing sessions... ${sessions.length} parsed (${Date.now() - startParse}ms)`);
+  }
+
+  if (sessions.length === 0) {
+    console.log('\x1b[33mNo Claude Code sessions found.\x1b[0m');
+    console.log('Make sure you have used Claude Code and session files exist in ~/.claude/projects/');
+    process.exit(0);
+  }
+
+  // Step 2: Analyze git repos
+  const startGit = Date.now();
+  const repoPathsSet = new Set(sessions.map(s => s.repoPath).filter(Boolean));
+  const commitsByRepo = {};
+  for (const repoPath of repoPathsSet) {
+    commitsByRepo[repoPath] = analyzeGitRepo(repoPath, days);
+  }
+  console.log(`Analyzing ${repoPathsSet.size} git repo(s)... done (${Date.now() - startGit}ms)`);
+
+  // Step 3: Correlate sessions with commits
+  const { correlatedSessions, organicCommits } = correlateSessions(sessions, commitsByRepo);
+  console.log('Correlating sessions with commits... done');
+
+  // Step 4: Compute metrics
+  const payload = computeMetrics(correlatedSessions, organicCommits, commitsByRepo, days);
+  payload.meta.gitUser = getGitUser();
+
+  // Save cache for next run
+  saveCache(sessions, fileIndex);
+
+  // Step 5: Output
+  if (opts.json) {
+    process.stdout.write(JSON.stringify(payload, null, 2));
+    process.exit(0);
+  }
+
+  // Start server
+  const app = createServer(payload);
+  const server = app.listen(port, () => {
+    const url = `http://localhost:${port}`;
+    console.log(`\x1b[32mDashboard:\x1b[0m ${url}`);
+
+    if (opts.open !== false) {
+      import('open').then(mod => mod.default(url)).catch(() => {
+        console.log('Could not auto-open browser. Visit the URL above.');
+      });
+    }
+  });
+
+  server.on('error', (err) => {
+    if (err.code === 'EADDRINUSE') {
+      console.error(`\x1b[31mPort ${port} is already in use.\x1b[0m Try: claude-roi --port ${port + 1}`);
+      process.exit(1);
+    }
+    throw err;
+  });
+}
+
+main().catch(err => {
+  console.error('\x1b[31mError:\x1b[0m', err.message);
+  process.exit(1);
+});

package/src/metrics.js

@@ -0,0 +1,396 @@
+import { getModelFamily } from './claude-parser.js';
+
+const CHURN_WINDOW_MS = 24 * 60 * 60 * 1000; // 24 hours
+
+function computeLineSurvival(commitsByRepo) {
+  let totalAdded = 0;
+  let totalChurned = 0;
+
+  for (const analysis of Object.values(commitsByRepo)) {
+    const userCommits = analysis.commits;
+    if (!userCommits.length) continue;
+
+    // Group commits by file
+    const fileTimeline = new Map();
+    for (const commit of userCommits) {
+      for (const file of commit.files) {
+        if (!fileTimeline.has(file.path)) fileTimeline.set(file.path, []);
+        fileTimeline.get(file.path).push({
+          timestampMs: commit.timestampMs,
+          added: file.added,
+          deleted: file.deleted,
+        });
+      }
+    }
+
+    // For each file, check for churn within 24h
+    for (const entries of fileTimeline.values()) {
+      entries.sort((a, b) => a.timestampMs - b.timestampMs);
+      for (let i = 0; i < entries.length; i++) {
+        totalAdded += entries[i].added;
+        if (i + 1 < entries.length) {
+          const gap = entries[i + 1].timestampMs - entries[i].timestampMs;
+          if (gap <= CHURN_WINDOW_MS) {
+            const churned = Math.min(entries[i + 1].deleted, entries[i].added);
+            totalChurned += churned;
+          }
+        }
+      }
+    }
+  }
+
+  const surviving = totalAdded - totalChurned;
+  // Round to nearest 5% to avoid false precision
+  const rawRate = totalAdded > 0 ? (surviving / totalAdded) * 100 : 100;
+  const survivalRate = Math.round(rawRate / 5) * 5;
+
+  return { totalAdded, totalChurned, surviving, survivalRate };
+}
+
+function computeEfficiencyGrade(costPerCommit, survivalRate) {
+  // Grade based on cost per commit (more meaningful than raw token count)
+  if (costPerCommit <= 2 && survivalRate >= 90) return 'A';
+  if (costPerCommit <= 5 && survivalRate >= 75) return 'B';
+  if (costPerCommit <= 15 && survivalRate >= 50) return 'C';
+  if (costPerCommit <= 40 && survivalRate >= 25) return 'D';
+  return 'F';
+}
+
+function computeSessionGrade(session) {
+  if (session.commitCount === 0) return 'F';
+  const costPerCommit = session.cost.totalCost / session.commitCount;
+  // Use 80 as a default survival (we don't have per-session survival)
+  return computeEfficiencyGrade(costPerCommit, 80);
+}
+
+function generateInsights(summary, correlatedSessions, modelBreakdown, sessionBuckets) {
+  const insights = [];
+
+  // Orphaned session rate
+  const orphanedCount = correlatedSessions.filter(s => s.isOrphaned).length;
+  if (orphanedCount > 0) {
+    const pct = Math.round((orphanedCount / correlatedSessions.length) * 100);
+    insights.push({
+      type: 'warning',
+      text: `${pct}% of your sessions (${orphanedCount}/${correlatedSessions.length}) produced zero commits — potential wasted effort.`,
+    });
+  }
+
+  // Model comparison
+  const modelFamilies = Object.entries(modelBreakdown).filter(([, d]) => d.sessions > 0);
+  if (modelFamilies.length > 1) {
+    const sorted = modelFamilies.sort((a, b) => (a[1].avgCostPerCommit || Infinity) - (b[1].avgCostPerCommit || Infinity));
+    const best = sorted[0];
+    const worst = sorted[sorted.length - 1];
+    if (best[1].avgCostPerCommit && worst[1].avgCostPerCommit) {
+      const ratio = (worst[1].avgCostPerCommit / best[1].avgCostPerCommit).toFixed(1);
+      insights.push({
+        type: 'info',
+        text: `${capitalise(worst[0])} sessions cost ${ratio}x more per commit than ${capitalise(best[0])}.`,
+      });
+    }
+  }
+
+  // Session length sweet spot
+  const bucketEntries = Object.entries(sessionBuckets).filter(([, d]) => d.sessions > 0 && d.avgCostPerCommit !== null);
+  if (bucketEntries.length > 1) {
+    const bestBucket = bucketEntries.reduce((a, b) =>
+      (a[1].avgCostPerCommit || Infinity) < (b[1].avgCostPerCommit || Infinity) ? a : b
+    );
+    insights.push({
+      type: 'tip',
+      text: `Sessions with ${bestBucket[0]} messages have the best cost-per-commit ($${bestBucket[1].avgCostPerCommit.toFixed(2)}).`,
+    });
+  }
+
+  // Peak productivity hours
+  if (summary.totalCommits > 0) {
+    // Best day of week
+    const bestDay = summary.bestDay;
+    const worstDay = summary.worstDay;
+    if (bestDay) {
+      insights.push({
+        type: 'success',
+        text: `${bestDay.date} was your most productive AI day — ${bestDay.commits} commits for $${bestDay.cost.toFixed(2)}.`,
+      });
+    }
+    if (worstDay && worstDay.date !== bestDay?.date) {
+      insights.push({
+        type: 'warning',
+        text: `${worstDay.date} had the worst ROI — ${worstDay.commits} commits for $${worstDay.cost.toFixed(2)}.`,
+      });
+    }
+  }
+
+  // Commits on main
+  const totalOnMain = correlatedSessions.reduce((s, cs) => s + cs.commitsOnMain, 0);
+  if (summary.totalCommits > 0) {
+    const pct = Math.round((totalOnMain / summary.totalCommits) * 100);
+    let mainText;
+    if (pct < 30) {
+      mainText = `${pct}% of AI-assisted commits landed on production — this is normal if you primarily work on feature branches.`;
+    } else if (pct >= 70) {
+      mainText = `${pct}% of AI-assisted commits landed directly on production.`;
+    } else {
+      mainText = `${pct}% of AI-assisted commits landed on production.`;
+    }
+    insights.push({
+      type: pct >= 50 ? 'success' : 'info',
+      text: mainText,
+    });
+  }
+
+  // Cost distribution
+  if (summary.totalCost > 0) {
+    const top20 = correlatedSessions
+      .sort((a, b) => b.cost.totalCost - a.cost.totalCost)
+      .slice(0, Math.max(1, Math.ceil(correlatedSessions.length * 0.2)));
+    const top20Cost = top20.reduce((s, c) => s + c.cost.totalCost, 0);
+    const pct = Math.round((top20Cost / summary.totalCost) * 100);
+    if (pct >= 60) {
+      insights.push({
+        type: 'info',
+        text: `Top 20% of sessions account for ${pct}% of total cost.`,
+      });
+    }
+  }
+
+  // Average session duration insight
+  const avgDuration = correlatedSessions.reduce((s, c) => s + c.durationMinutes, 0) / correlatedSessions.length;
+  if (avgDuration > 0) {
+    insights.push({
+      type: 'info',
+      text: `Average session duration: ${Math.round(avgDuration)} minutes.`,
+    });
+  }
+
+  // Average commit delay (time between session end and commit)
+  const delays = [];
+  for (const session of correlatedSessions) {
+    if (session.commits.length === 0) continue;
+    const sessionEnd = new Date(session.endTime).getTime();
+    for (const c of session.commits) {
+      const delay = c.timestampMs - sessionEnd;
+      if (delay >= 0) delays.push(delay);
+    }
+  }
+  if (delays.length > 0) {
+    const avgDelayMs = delays.reduce((s, d) => s + d, 0) / delays.length;
+    const avgDelayHours = avgDelayMs / (1000 * 60 * 60);
+    if (avgDelayHours < 1) {
+      insights.push({ type: 'success', text: `On average, commits happen ${Math.round(avgDelayHours * 60)} minutes after a session ends.` });
+    } else {
+      insights.push({ type: 'info', text: `On average, commits happen ${avgDelayHours.toFixed(1)} hours after a session ends.` });
+    }
+  }
+
+  // Uncommitted files insight
+  const totalUncommitted = correlatedSessions.reduce((s, c) => s + (c.uncommittedFiles?.length || 0), 0);
+  const totalWritten = correlatedSessions.reduce((s, c) => s + (c.filesWritten?.length || 0), 0);
+  if (totalWritten > 0 && totalUncommitted > 0) {
+    const pct = Math.round((totalUncommitted / totalWritten) * 100);
+    if (pct >= 20) {
+      insights.push({ type: 'info', text: `${pct}% of files Claude edited (${totalUncommitted}/${totalWritten}) were not found in any commit.` });
+    }
+  }
+
+  return insights;
+}
+
+function capitalise(s) {
+  return s.charAt(0).toUpperCase() + s.slice(1);
+}
+
+export function computeMetrics(correlatedSessions, organicCommits, commitsByRepo, days) {
+  // ---- Summary ----
+  const totalCost = correlatedSessions.reduce((s, c) => s + c.cost.totalCost, 0);
+  const totalSessions = correlatedSessions.length;
+  const totalCommits = correlatedSessions.reduce((s, c) => s + c.commitCount, 0);
+  const totalLinesAdded = correlatedSessions.reduce((s, c) => s + c.linesAdded, 0);
+  const totalLinesDeleted = correlatedSessions.reduce((s, c) => s + c.linesDeleted, 0);
+  const totalNetLines = totalLinesAdded - totalLinesDeleted;
+  const totalFilesChanged = new Set(
+    correlatedSessions.flatMap(c => c.commits.flatMap(co => co.files.map(f => f.path)))
+  ).size;
+  const totalInputTokens = correlatedSessions.reduce((s, c) => s + c.totalInputTokens, 0);
+  const totalOutputTokens = correlatedSessions.reduce((s, c) => s + c.totalOutputTokens, 0);
+  const orphanedCount = correlatedSessions.filter(s => s.isOrphaned).length;
+  const totalCommitsOnMain = correlatedSessions.reduce((s, c) => s + c.commitsOnMain, 0);
+
+  const lineSurvival = computeLineSurvival(commitsByRepo);
+
+  const avgCost = totalCommits > 0 ? totalCost / totalCommits : 0;
+  const overallGrade = totalCommits > 0
+    ? computeEfficiencyGrade(avgCost, lineSurvival.survivalRate)
+    : 'F';
+
+  // ---- Daily timeline ----
+  const dailyMap = new Map();
+  for (const session of correlatedSessions) {
+    const d = new Date(session.startTime);
+    const date = `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, '0')}-${String(d.getDate()).padStart(2, '0')}`;
+    if (!dailyMap.has(date)) {
+      dailyMap.set(date, { date, cost: 0, sessions: 0, commits: 0, linesAdded: 0, linesDeleted: 0, netLines: 0 });
+    }
+    const day = dailyMap.get(date);
+    day.cost += session.cost.totalCost;
+    day.sessions++;
+    day.commits += session.commitCount;
+    day.linesAdded += session.linesAdded;
+    day.linesDeleted += session.linesDeleted;
+    day.netLines += session.netLines;
+  }
+  const daily = [...dailyMap.values()].sort((a, b) => a.date.localeCompare(b.date));
+
+  // Best/worst days
+  const daysWithCommits = daily.filter(d => d.commits > 0);
+  const bestDay = daysWithCommits.length > 0
+    ? daysWithCommits.reduce((a, b) => (b.commits / Math.max(b.cost, 0.01)) > (a.commits / Math.max(a.cost, 0.01)) ? b : a)
+    : null;
+  const worstDay = daysWithCommits.length > 0
+    ? daysWithCommits.reduce((a, b) => (b.commits / Math.max(b.cost, 0.01)) < (a.commits / Math.max(a.cost, 0.01)) ? b : a)
+    : null;
+
+  // ---- Model breakdown ----
+  const modelBreakdown = {};
+  for (const session of correlatedSessions) {
+    for (const [model, data] of Object.entries(session.modelBreakdown)) {
+      const family = getModelFamily(model) || 'unknown';
+      if (!modelBreakdown[family]) {
+        modelBreakdown[family] = { cost: 0, tokens: 0, sessions: 0, commits: 0, avgCostPerCommit: null };
+      }
+      modelBreakdown[family].cost += data.cost;
+      modelBreakdown[family].tokens += data.tokens;
+    }
+    // Count sessions/commits per primary model
+    const primaryFamily = getModelFamily(session.model) || 'unknown';
+    if (!modelBreakdown[primaryFamily]) {
+      modelBreakdown[primaryFamily] = { cost: 0, tokens: 0, sessions: 0, commits: 0, avgCostPerCommit: null };
+    }
+    modelBreakdown[primaryFamily].sessions++;
+    modelBreakdown[primaryFamily].commits += session.commitCount;
+  }
+  for (const data of Object.values(modelBreakdown)) {
+    data.avgCostPerCommit = data.commits > 0 ? data.cost / data.commits : null;
+  }
+
+  // ---- Tool breakdown ----
+  const toolBreakdown = {};
+  for (const session of correlatedSessions) {
+    for (const [tool, count] of Object.entries(session.toolCalls)) {
+      toolBreakdown[tool] = (toolBreakdown[tool] || 0) + count;
+    }
+  }
+
+  // ---- Session length buckets ----
+  const buckets = { '1-50': [], '51-100': [], '101-200': [], '200+': [] };
+  for (const session of correlatedSessions) {
+    const msgCount = session.userMessageCount + session.assistantMessageCount;
+    if (msgCount <= 50) buckets['1-50'].push(session);
+    else if (msgCount <= 100) buckets['51-100'].push(session);
+    else if (msgCount <= 200) buckets['101-200'].push(session);
+    else buckets['200+'].push(session);
+  }
+  const sessionBuckets = {};
+  for (const [label, sessions] of Object.entries(buckets)) {
+    const cost = sessions.reduce((s, c) => s + c.cost.totalCost, 0);
+    const commits = sessions.reduce((s, c) => s + c.commitCount, 0);
+    sessionBuckets[label] = {
+      sessions: sessions.length,
+      cost,
+      commits,
+      avgCostPerCommit: commits > 0 ? cost / commits : null,
+    };
+  }
+
+  // ---- Heatmap (hour x day-of-week) ----
+  const heatmap = Array.from({ length: 7 }, () => Array(24).fill(0));
+  const heatmapCost = Array.from({ length: 7 }, () => Array(24).fill(0));
+  for (const session of correlatedSessions) {
+    // Place each commit at its actual timestamp, not the session start
+    for (const commit of session.commits) {
+      const d = new Date(commit.timestamp);
+      const dayOfWeek = d.getDay(); // 0=Sun
+      const hour = d.getHours();
+      heatmap[dayOfWeek][hour]++;
+    }
+    // Cost is still attributed to session start time
+    const sd = new Date(session.startTime);
+    heatmapCost[sd.getDay()][sd.getHours()] += session.cost.totalCost;
+  }
+
+  // ---- Per-project breakdown ----
+  const projectMap = new Map();
+  for (const session of correlatedSessions) {
+    const key = session.repoPath || 'unknown';
+    if (!projectMap.has(key)) {
+      projectMap.set(key, {
+        repoPath: key,
+        repoName: session.projectName || key.split('/').pop(),
+        totalCost: 0, sessions: 0, commits: 0, linesAdded: 0, commitsOnMain: 0,
+      });
+    }
+    const p = projectMap.get(key);
+    p.totalCost += session.cost.totalCost;
+    p.sessions++;
+    p.commits += session.commitCount;
+    p.linesAdded += session.linesAdded;
+    p.commitsOnMain += session.commitsOnMain;
+  }
+  const projects = [...projectMap.values()].map(p => ({
+    ...p,
+    avgCostPerLine: p.linesAdded > 0 ? p.totalCost / p.linesAdded : null,
+    mainBranchPct: p.commits > 0 ? Math.round((p.commitsOnMain / p.commits) * 100) : 0,
+  }));
+
+  // Add grades to sessions
+  const sessionsWithGrades = correlatedSessions.map(s => ({
+    ...s,
+    grade: computeSessionGrade(s),
+  }));
+
+  const summary = {
+    totalCost,
+    totalSessions,
+    totalCommits,
+    totalLinesAdded,
+    totalLinesDeleted,
+    totalNetLines,
+    totalFilesChanged,
+    avgCostPerCommit: totalCommits > 0 ? totalCost / totalCommits : null,
+    avgCostPerLine: totalLinesAdded > 0 ? totalCost / totalLinesAdded : null,
+    totalInputTokens,
+    totalOutputTokens,
+    orphanedSessionRate: totalSessions > 0 ? Math.round((orphanedCount / totalSessions) * 100) : 0,
+    lineSurvivalRate: lineSurvival.survivalRate,
+    overallGrade,
+    totalCommitsOnMain,
+    mainBranchPct: totalCommits > 0 ? Math.round((totalCommitsOnMain / totalCommits) * 100) : 0,
+    organicCommitCount: organicCommits.length,
+    bestDay,
+    worstDay,
+  };
+
+  const insights = generateInsights(summary, correlatedSessions, modelBreakdown, sessionBuckets);
+
+  return {
+    meta: {
+      generatedAt: new Date().toISOString(),
+      daysAnalyzed: days,
+      defaultBranches: Object.fromEntries(
+        Object.entries(commitsByRepo).map(([repo, a]) => [repo.split('/').pop(), a.defaultBranch]).filter(([, b]) => b)
+      ),
+    },
+    summary,
+    insights,
+    daily,
+    projects,
+    sessions: sessionsWithGrades,
+    modelBreakdown,
+    toolBreakdown,
+    sessionBuckets,
+    lineSurvival,
+    heatmap: { commits: heatmap, cost: heatmapCost },
+    organicCommits,
+  };
+}