chekk 0.5.4 → 1.0.0

package/src/metrics/session-structure.js

@@ -1,199 +0,0 @@
-/**
- * Session Structure / Workflow Quality
- *
- * Measures how deliberate and structured the engineer's workflow is.
- *
- * Signals:
- * - Do sessions start with context-setting? (explaining what needs to happen)
- * - Do they plan before diving into code?
- * - Is there a review/validation step at the end?
- * - Session duration distribution (very short = throwaway, very long = unfocused)
- * - Modification rate of AI output (shows critical review)
- */
-
-// ── Evidence quality filter ──
-const noisePatterns = /^This session is being continued|^\[?[0-9T:.Z-]{20,}|^\S+@\S+.*[%$#>]|^\s*\$\s|^\s*>\s/;
-function isGoodEvidence(prompt) {
-  if (!prompt || prompt.length < 40 || prompt.length > 600) return false;
-  if (noisePatterns.test(prompt)) return false;
-  const alpha = prompt.replace(/[^a-zA-Z]/g, '').length;
-  if (alpha / prompt.length < 0.4) return false;
-  return true;
-}
-
-const contextSettingPatterns = /^(i('?m| am) (working on|building|trying to|looking at)|we need to|the goal is|here'?s (the|what)|context:|background:|i have a|there'?s a|i want to|let me explain)/i;
-const planningStartPatterns = /^(let'?s (plan|think|figure|start by)|first,? (let'?s|we should)|before we (start|begin|code)|the plan is|step 1|here'?s (my|the) plan)/i;
-const reviewPatterns = /\b(looks good|ship it|deploy|push it|commit|merge|let'?s go|lgtm|approved|test it|run (the )?tests|build it|does this look|review this|check this)\b/i;
-const refinementPatterns = /\b(actually|wait|hmm|instead|change|modify|tweak|adjust|no,? |not quite|close but|almost|that'?s not)\b/i;
-
-export function computeSessionStructure(sessions) {
-  if (sessions.length === 0) return { score: 50, details: {} };
-
-  let contextSetSessions = 0;
-  let planBeforeCodeSessions = 0;
-  let reviewEndSessions = 0;
-  let refinementCount = 0;
-  let totalExchanges = 0;
-
-  // Duration distribution
-  let shortSessions = 0; // < 5 min
-  let mediumSessions = 0; // 5-60 min
-  let longSessions = 0; // > 60 min
-  let focusedSessions = 0; // 10-45 min (sweet spot)
-
-  // First prompt length distribution (longer first prompts = more context setting)
-  let firstPromptTotalLength = 0;
-
-  // Capture representative examples
-  let bestContextPrompt = null; // best context-setting opener
-  let bestRefinementPrompt = null; // best refinement/critical feedback
-  let bestContextLen = 0;
-
-  for (const session of sessions) {
-    const { exchanges, durationMinutes } = session;
-    if (exchanges.length === 0) continue;
-
-    totalExchanges += exchanges.length;
-
-    // Check if session starts with context
-    const firstPrompt = exchanges[0].userPrompt || '';
-    firstPromptTotalLength += firstPrompt.length;
-
-    if (contextSettingPatterns.test(firstPrompt) || firstPrompt.length > 200) {
-      contextSetSessions++;
-      // Track best context-setting prompt
-      if (isGoodEvidence(firstPrompt) && firstPrompt.length > bestContextLen) {
-        bestContextLen = firstPrompt.length;
-        bestContextPrompt = firstPrompt;
-      }
-    }
-
-    if (planningStartPatterns.test(firstPrompt)) {
-      planBeforeCodeSessions++;
-    }
-
-    // Check if session ends with review/validation
-    if (exchanges.length >= 2) {
-      const lastPrompt = exchanges[exchanges.length - 1].userPrompt || '';
-      const secondLastPrompt = exchanges.length >= 3 ? exchanges[exchanges.length - 2].userPrompt || '' : '';
-      if (reviewPatterns.test(lastPrompt) || reviewPatterns.test(secondLastPrompt)) {
-        reviewEndSessions++;
-      }
-    }
-
-    // Count refinements (shows critical evaluation)
-    for (let i = 1; i < exchanges.length; i++) {
-      const prompt = exchanges[i].userPrompt || '';
-      if (refinementPatterns.test(prompt)) {
-        refinementCount++;
-        // Track best refinement example
-        if (isGoodEvidence(prompt) && (!bestRefinementPrompt || prompt.length > bestRefinementPrompt.length)) {
-          bestRefinementPrompt = prompt;
-        }
-      }
-    }
-
-    // Duration buckets
-    if (durationMinutes !== undefined && durationMinutes !== null) {
-      if (durationMinutes < 5) shortSessions++;
-      else if (durationMinutes <= 60) mediumSessions++;
-      else longSessions++;
-
-      if (durationMinutes >= 10 && durationMinutes <= 45) focusedSessions++;
-    }
-  }
-
-  const sessionsWithExchanges = sessions.filter(s => s.exchanges.length > 0).length;
-
-  // Score components
-  const contextRatio = sessionsWithExchanges > 0 ? contextSetSessions / sessionsWithExchanges : 0;
-  const contextScore = Math.min(100, contextRatio * 170);
-
-  const planRatio = sessionsWithExchanges > 0 ? planBeforeCodeSessions / sessionsWithExchanges : 0;
-  const planScore = Math.min(100, planRatio * 300);
-
-  const reviewRatio = sessionsWithExchanges > 0 ? reviewEndSessions / sessionsWithExchanges : 0;
-  const reviewScore = Math.min(100, reviewRatio * 200);
-
-  // Refinement shows critical thinking
-  const refinementRatio = totalExchanges > 0 ? refinementCount / totalExchanges : 0;
-  const refinementScore = Math.min(100, refinementRatio * 400);
-
-  // Duration focus (medium/focused sessions are ideal)
-  const totalWithDuration = shortSessions + mediumSessions + longSessions;
-  const focusedRatio = totalWithDuration > 0 ? focusedSessions / totalWithDuration : 0.5;
-  const focusScore = Math.min(100, focusedRatio * 170);
-
-  // Average first prompt length (longer = more thoughtful setup)
-  const avgFirstPromptLength = sessionsWithExchanges > 0 ? firstPromptTotalLength / sessionsWithExchanges : 0;
-  const firstPromptScore = avgFirstPromptLength > 300 ? 90 :
-                           avgFirstPromptLength > 150 ? 75 :
-                           avgFirstPromptLength > 50 ? 55 : 35;
-
-  const score = Math.round(
-    contextScore * 0.2 +
-    planScore * 0.15 +
-    reviewScore * 0.15 +
-    refinementScore * 0.2 +
-    focusScore * 0.15 +
-    firstPromptScore * 0.15
-  );
-
-  // Build examples array
-  const examples = [];
-  if (bestContextPrompt) examples.push({ type: 'context_setting', prompt: bestContextPrompt });
-  if (bestRefinementPrompt) examples.push({ type: 'refinement', prompt: bestRefinementPrompt });
-
-  // ── Token cost evidence ──
-  // Compare token cost of focused sessions vs marathon sessions
-  let focusedTokens = 0, focusedTokenCount = 0;
-  let marathonTokens = 0, marathonTokenCount = 0;
-  let contextSetTokens = 0, contextSetCount = 0;
-  let noContextTokens = 0, noContextCount = 0;
-
-  for (const session of sessions) {
-    const t = session.tokenUsage;
-    if (!t || (t.inputTokens + t.outputTokens + t.cacheReadTokens + t.cacheCreationTokens) === 0) continue;
-    const total = t.inputTokens + t.outputTokens + t.cacheReadTokens + t.cacheCreationTokens;
-    const perExchange = session.exchangeCount > 0 ? total / session.exchangeCount : total;
-
-    // Duration-based
-    if (session.durationMinutes >= 10 && session.durationMinutes <= 45) {
-      focusedTokens += perExchange; focusedTokenCount++;
-    } else if (session.durationMinutes > 60) {
-      marathonTokens += perExchange; marathonTokenCount++;
-    }
-
-    // Context-setting vs not
-    const firstPrompt = session.exchanges[0]?.userPrompt || '';
-    if (contextSettingPatterns.test(firstPrompt) || firstPrompt.length > 200) {
-      contextSetTokens += perExchange; contextSetCount++;
-    } else if (session.exchanges.length > 0) {
-      noContextTokens += perExchange; noContextCount++;
-    }
-  }
-
-  return {
-    score: Math.max(0, Math.min(100, score)),
-    details: {
-      contextSetRatio: Math.round(contextRatio * 100),
-      planBeforeCodeRatio: Math.round(planRatio * 100),
-      reviewEndRatio: Math.round(reviewRatio * 100),
-      refinementRatio: Math.round(refinementRatio * 100),
-      avgFirstPromptLength: Math.round(avgFirstPromptLength),
-      durationDistribution: {
-        short: shortSessions,
-        medium: mediumSessions,
-        long: longSessions,
-        focused: focusedSessions,
-      },
-      tokenEvidence: {
-        avgTokensPerExchangeFocused: focusedTokenCount > 0 ? Math.round(focusedTokens / focusedTokenCount) : null,
-        avgTokensPerExchangeMarathon: marathonTokenCount > 0 ? Math.round(marathonTokens / marathonTokenCount) : null,
-        avgTokensPerExchangeWithContext: contextSetCount > 0 ? Math.round(contextSetTokens / contextSetCount) : null,
-        avgTokensPerExchangeNoContext: noContextCount > 0 ? Math.round(noContextTokens / noContextCount) : null,
-      },
-    },
-    examples,
-  };
-}

package/src/metrics/token-efficiency.js

@@ -1,258 +0,0 @@
-/**
- * Token Efficiency Analytics
- *
- * Computes token spend statistics from Claude Code session data.
- * This is NOT a scored dimension — it provides concrete evidence
- * that enriches the existing 4 metrics with cost data.
- *
- * Outputs:
- * - Total token breakdown (input, output, cache read, cache creation)
- * - Estimated cost using Anthropic pricing
- * - Per-project token breakdown
- * - Costliest sessions and prompts
- * - Cache efficiency ratio (how much context is re-read vs new)
- * - Prompt-type cost analysis (vague vs specific, short vs long)
- */
-
-// ── Anthropic pricing per million tokens (as of early 2025) ──
-// Claude Code uses a mix of models; we estimate with Sonnet pricing
-// which is the most common model in Claude Code sessions.
-const PRICING = {
-  'claude-sonnet-4-5-20250929': { input: 3.00, output: 15.00, cacheRead: 0.30, cacheCreation: 3.75 },
-  'claude-opus-4-6':            { input: 15.00, output: 75.00, cacheRead: 1.50, cacheCreation: 18.75 },
-  'claude-haiku-4-5-20251001':  { input: 0.80, output: 4.00, cacheRead: 0.08, cacheCreation: 1.00 },
-  // Fallback for unknown models — use Sonnet pricing as default
-  default:                      { input: 3.00, output: 15.00, cacheRead: 0.30, cacheCreation: 3.75 },
-};
-
-function getPricing(model) {
-  if (!model) return PRICING.default;
-  for (const [key, prices] of Object.entries(PRICING)) {
-    if (key !== 'default' && model.includes(key.replace(/-\d+$/, ''))) return prices;
-  }
-  // Try partial match
-  if (model.includes('opus')) return PRICING['claude-opus-4-6'];
-  if (model.includes('haiku')) return PRICING['claude-haiku-4-5-20251001'];
-  if (model.includes('sonnet')) return PRICING['claude-sonnet-4-5-20250929'];
-  return PRICING.default;
-}
-
-function estimateCost(tokens, pricing) {
-  return (
-    (tokens.inputTokens / 1_000_000) * pricing.input +
-    (tokens.outputTokens / 1_000_000) * pricing.output +
-    (tokens.cacheReadTokens / 1_000_000) * pricing.cacheRead +
-    (tokens.cacheCreationTokens / 1_000_000) * pricing.cacheCreation
-  );
-}
-
-function addTokens(target, source) {
-  target.inputTokens += source.inputTokens || 0;
-  target.outputTokens += source.outputTokens || 0;
-  target.cacheReadTokens += source.cacheReadTokens || 0;
-  target.cacheCreationTokens += source.cacheCreationTokens || 0;
-}
-
-function totalTokens(t) {
-  return (t.inputTokens || 0) + (t.outputTokens || 0) + (t.cacheReadTokens || 0) + (t.cacheCreationTokens || 0);
-}
-
-/**
- * Compute comprehensive token efficiency analytics.
- *
- * @param {Array} sessions - Parsed sessions with tokenUsage on each exchange
- * @returns {Object} Token analytics data (not a score)
- */
-export function computeTokenEfficiency(sessions) {
-  if (sessions.length === 0) {
-    return { hasData: false };
-  }
-
-  // Check if any session has token data (only Claude Code currently provides this)
-  const sessionsWithTokens = sessions.filter(s =>
-    s.tokenUsage && totalTokens(s.tokenUsage) > 0
-  );
-
-  if (sessionsWithTokens.length === 0) {
-    return { hasData: false };
-  }
-
-  // ── Aggregate totals ──
-  const totals = { inputTokens: 0, outputTokens: 0, cacheReadTokens: 0, cacheCreationTokens: 0 };
-  for (const s of sessionsWithTokens) {
-    addTokens(totals, s.tokenUsage);
-  }
-
-  const grandTotal = totalTokens(totals);
-
-  // ── Cost estimation ──
-  // For now use default pricing; could be refined per-message if model data is on exchanges
-  const pricing = PRICING.default;
-  const estimatedCostTotal = estimateCost(totals, pricing);
-
-  // ── Token composition ──
-  const composition = {
-    inputPct: grandTotal > 0 ? (totals.inputTokens / grandTotal * 100) : 0,
-    outputPct: grandTotal > 0 ? (totals.outputTokens / grandTotal * 100) : 0,
-    cacheReadPct: grandTotal > 0 ? (totals.cacheReadTokens / grandTotal * 100) : 0,
-    cacheCreationPct: grandTotal > 0 ? (totals.cacheCreationTokens / grandTotal * 100) : 0,
-  };
-
-  // The "context re-reading" ratio: cache_read / (cache_read + output)
-  // This shows how much of Claude's work is re-reading vs producing new output
-  const contextRereadRatio = (totals.cacheReadTokens + totals.outputTokens) > 0
-    ? totals.cacheReadTokens / (totals.cacheReadTokens + totals.outputTokens)
-    : 0;
-
-  // ── Per-project breakdown ──
-  const projectTokens = {};
-  for (const s of sessionsWithTokens) {
-    const p = s.project || 'unknown';
-    if (!projectTokens[p]) {
-      projectTokens[p] = {
-        tokens: { inputTokens: 0, outputTokens: 0, cacheReadTokens: 0, cacheCreationTokens: 0 },
-        sessions: 0,
-        exchanges: 0,
-      };
-    }
-    addTokens(projectTokens[p].tokens, s.tokenUsage);
-    projectTokens[p].sessions++;
-    projectTokens[p].exchanges += s.exchangeCount;
-  }
-
-  const perProject = Object.entries(projectTokens)
-    .map(([name, data]) => ({
-      name: name.length > 30 ? '...' + name.slice(-27) : name,
-      fullName: name,
-      totalTokens: totalTokens(data.tokens),
-      estimatedCost: estimateCost(data.tokens, pricing),
-      sessions: data.sessions,
-      exchanges: data.exchanges,
-      tokensPerExchange: data.exchanges > 0 ? Math.round(totalTokens(data.tokens) / data.exchanges) : 0,
-      ...data.tokens,
-    }))
-    .sort((a, b) => b.totalTokens - a.totalTokens);
-
-  // ── Costliest sessions ──
-  const costliestSessions = sessionsWithTokens
-    .map(s => ({
-      id: s.id,
-      project: s.project || 'unknown',
-      totalTokens: totalTokens(s.tokenUsage),
-      estimatedCost: estimateCost(s.tokenUsage, pricing),
-      exchanges: s.exchangeCount,
-      durationMinutes: s.durationMinutes,
-      cacheReadRatio: totalTokens(s.tokenUsage) > 0
-        ? s.tokenUsage.cacheReadTokens / totalTokens(s.tokenUsage)
-        : 0,
-      firstPrompt: s.exchanges[0]?.userPrompt?.slice(0, 80) || '',
-    }))
-    .sort((a, b) => b.totalTokens - a.totalTokens)
-    .slice(0, 5);
-
-  // ── Costliest exchanges (individual prompts) ──
-  const allExchanges = [];
-  for (const s of sessionsWithTokens) {
-    for (let i = 0; i < s.exchanges.length; i++) {
-      const ex = s.exchanges[i];
-      if (!ex.tokenUsage || totalTokens(ex.tokenUsage) === 0) continue;
-      allExchanges.push({
-        prompt: ex.userPrompt || '',
-        totalTokens: totalTokens(ex.tokenUsage),
-        estimatedCost: estimateCost(ex.tokenUsage, pricing),
-        cacheReadTokens: ex.tokenUsage.cacheReadTokens,
-        outputTokens: ex.tokenUsage.outputTokens,
-        sessionId: s.id,
-        project: s.project || 'unknown',
-        exchangeIndex: i,
-      });
-    }
-  }
-
-  allExchanges.sort((a, b) => b.totalTokens - a.totalTokens);
-  const costliestExchanges = allExchanges.slice(0, 5);
-
-  // ── Prompt length vs token cost correlation ──
-  // Group exchanges by prompt length buckets and compute avg token cost
-  const buckets = {
-    veryShort: { label: '< 20 chars', prompts: 0, totalTokens: 0, totalCost: 0 },
-    short: { label: '20-100 chars', prompts: 0, totalTokens: 0, totalCost: 0 },
-    medium: { label: '100-500 chars', prompts: 0, totalTokens: 0, totalCost: 0 },
-    long: { label: '500+ chars', prompts: 0, totalTokens: 0, totalCost: 0 },
-  };
-
-  for (const ex of allExchanges) {
-    const len = ex.prompt.length;
-    let bucket;
-    if (len < 20) bucket = buckets.veryShort;
-    else if (len < 100) bucket = buckets.short;
-    else if (len < 500) bucket = buckets.medium;
-    else bucket = buckets.long;
-
-    bucket.prompts++;
-    bucket.totalTokens += ex.totalTokens;
-    bucket.totalCost += ex.estimatedCost;
-  }
-
-  const promptLengthAnalysis = Object.values(buckets)
-    .filter(b => b.prompts > 0)
-    .map(b => ({
-      ...b,
-      avgTokens: Math.round(b.totalTokens / b.prompts),
-      avgCost: b.totalCost / b.prompts,
-    }));
-
-  // ── Session length vs token efficiency ──
-  // Marathon sessions compound context, so later exchanges cost more
-  const sessionLengthAnalysis = {
-    short: { label: '1-5 exchanges', sessions: 0, avgTokensPerExchange: 0, totalTokens: 0, totalExchanges: 0 },
-    medium: { label: '6-20 exchanges', sessions: 0, avgTokensPerExchange: 0, totalTokens: 0, totalExchanges: 0 },
-    long: { label: '21-50 exchanges', sessions: 0, avgTokensPerExchange: 0, totalTokens: 0, totalExchanges: 0 },
-    marathon: { label: '50+ exchanges', sessions: 0, avgTokensPerExchange: 0, totalTokens: 0, totalExchanges: 0 },
-  };
-
-  for (const s of sessionsWithTokens) {
-    const ec = s.exchangeCount;
-    const t = totalTokens(s.tokenUsage);
-    let bucket;
-    if (ec <= 5) bucket = sessionLengthAnalysis.short;
-    else if (ec <= 20) bucket = sessionLengthAnalysis.medium;
-    else if (ec <= 50) bucket = sessionLengthAnalysis.long;
-    else bucket = sessionLengthAnalysis.marathon;
-
-    bucket.sessions++;
-    bucket.totalTokens += t;
-    bucket.totalExchanges += ec;
-  }
-
-  for (const bucket of Object.values(sessionLengthAnalysis)) {
-    bucket.avgTokensPerExchange = bucket.totalExchanges > 0
-      ? Math.round(bucket.totalTokens / bucket.totalExchanges)
-      : 0;
-  }
-
-  // ── Top-level stats ──
-  const avgTokensPerSession = sessionsWithTokens.length > 0
-    ? Math.round(grandTotal / sessionsWithTokens.length)
-    : 0;
-  const avgTokensPerExchange = allExchanges.length > 0
-    ? Math.round(grandTotal / allExchanges.length)
-    : 0;
-
-  return {
-    hasData: true,
-    sessionsAnalyzed: sessionsWithTokens.length,
-    totals,
-    grandTotal,
-    estimatedCostTotal,
-    composition,
-    contextRereadRatio,
-    avgTokensPerSession,
-    avgTokensPerExchange,
-    perProject,
-    costliestSessions,
-    costliestExchanges,
-    promptLengthAnalysis,
-    sessionLengthAnalysis: Object.values(sessionLengthAnalysis).filter(b => b.sessions > 0),
-  };
-}

package/src/parsers/claude-code.js

@@ -1,231 +0,0 @@
-import { readFileSync, readdirSync, statSync } from 'fs';
-import { join } from 'path';
-
-/**
- * Parse Claude Code JSONL session files into normalized format.
- *
- * Each JSONL line is one of:
- * - type: "user" → human prompt
- * - type: "assistant" → AI response (may contain text, thinking, tool_use)
- * - type: "summary" → session summary (skip)
- * - type: "file-history-snapshot" → file state (skip)
- *
- * We normalize into sessions, each with turns.
- */
-
-function parseJsonlLine(line) {
-  try {
-    return JSON.parse(line);
-  } catch {
-    return null;
-  }
-}
-
-function extractToolCalls(content) {
-  if (!Array.isArray(content)) return [];
-  return content
-    .filter(block => block.type === 'tool_use')
-    .map(block => ({
-      tool: block.name || block.input?.description || 'unknown',
-      input: block.input || {},
-    }));
-}
-
-function extractTextContent(content) {
-  if (typeof content === 'string') return content;
-  if (!Array.isArray(content)) return '';
-  return content
-    .filter(block => block.type === 'text')
-    .map(block => block.text || '')
-    .join('\n');
-}
-
-function extractThinking(content) {
-  if (!Array.isArray(content)) return '';
-  return content
-    .filter(block => block.type === 'thinking')
-    .map(block => block.thinking || '')
-    .join('\n');
-}
-
-function hasToolResults(content) {
-  if (!Array.isArray(content)) return false;
-  return content.some(block => block.type === 'tool_result');
-}
-
-/**
- * Parse a single JSONL file into a list of turns.
- */
-function parseSessionFile(filePath) {
-  let raw;
-  try {
-    raw = readFileSync(filePath, 'utf-8');
-  } catch {
-    return [];
-  }
-
-  const lines = raw.split('\n').filter(l => l.trim());
-  const turns = [];
-
-  for (const line of lines) {
-    const entry = parseJsonlLine(line);
-    if (!entry) continue;
-
-    // Skip non-message types
-    if (entry.type === 'summary' || entry.type === 'file-history-snapshot') continue;
-    if (!entry.message) continue;
-
-    const role = entry.message.role || entry.type;
-    if (role !== 'user' && role !== 'assistant') continue;
-
-    // Skip tool result messages (these are system-injected responses to tool calls)
-    if (role === 'user' && hasToolResults(entry.message.content)) continue;
-
-    // Extract token usage from assistant messages
-    const usage = (role === 'assistant' && entry.message.usage) ? {
-      inputTokens: entry.message.usage.input_tokens || 0,
-      outputTokens: entry.message.usage.output_tokens || 0,
-      cacheReadTokens: entry.message.usage.cache_read_input_tokens || 0,
-      cacheCreationTokens: entry.message.usage.cache_creation_input_tokens || 0,
-    } : null;
-
-    const turn = {
-      role,
-      text: extractTextContent(entry.message.content),
-      thinking: role === 'assistant' ? extractThinking(entry.message.content) : '',
-      toolCalls: role === 'assistant' ? extractToolCalls(entry.message.content) : [],
-      timestamp: entry.timestamp || null,
-      uuid: entry.uuid || null,
-      parentUuid: entry.parentUuid || null,
-      model: entry.message.model || null,
-      usage,
-    };
-
-    // Skip empty assistant messages that are just tool call continuations
-    if (role === 'assistant' && !turn.text && turn.toolCalls.length === 0 && !turn.thinking) {
-      continue;
-    }
-
-    turns.push(turn);
-  }
-
-  return turns;
-}
-
-/**
- * Group consecutive turns into logical conversation exchanges.
- * A "exchange" is one user prompt followed by all assistant responses until the next user prompt.
- */
-function groupIntoExchanges(turns) {
-  const exchanges = [];
-  let current = null;
-
-  for (const turn of turns) {
-    if (turn.role === 'user') {
-      if (current) exchanges.push(current);
-      current = {
-        userPrompt: turn.text,
-        userTimestamp: turn.timestamp,
-        assistantResponses: [],
-        toolCalls: [],
-        thinkingContent: [],
-        tokenUsage: { inputTokens: 0, outputTokens: 0, cacheReadTokens: 0, cacheCreationTokens: 0 },
-      };
-    } else if (turn.role === 'assistant' && current) {
-      if (turn.text) current.assistantResponses.push(turn.text);
-      if (turn.thinking) current.thinkingContent.push(turn.thinking);
-      current.toolCalls.push(...turn.toolCalls);
-      // Accumulate token usage across all assistant turns in this exchange
-      if (turn.usage) {
-        current.tokenUsage.inputTokens += turn.usage.inputTokens;
-        current.tokenUsage.outputTokens += turn.usage.outputTokens;
-        current.tokenUsage.cacheReadTokens += turn.usage.cacheReadTokens;
-        current.tokenUsage.cacheCreationTokens += turn.usage.cacheCreationTokens;
-      }
-    }
-  }
-
-  if (current) exchanges.push(current);
-  return exchanges;
-}
-
-/**
- * Parse all Claude Code sessions from a project directory.
- */
-export function parseProject(projectPath) {
-  const files = readdirSync(projectPath).filter(f =>
-    f.endsWith('.jsonl') && !f.startsWith('agent-')
-  );
-
-  const sessions = [];
-
-  for (const file of files) {
-    const filePath = join(projectPath, file);
-    const stat = statSync(filePath);
-
-    const turns = parseSessionFile(filePath);
-    if (turns.length === 0) continue;
-
-    const exchanges = groupIntoExchanges(turns);
-    if (exchanges.length === 0) continue;
-
-    // Get time range
-    const timestamps = turns
-      .map(t => t.timestamp)
-      .filter(Boolean)
-      .map(t => new Date(t).getTime())
-      .sort();
-
-    // Aggregate token usage across all exchanges in this session
-    const sessionTokens = { inputTokens: 0, outputTokens: 0, cacheReadTokens: 0, cacheCreationTokens: 0 };
-    for (const ex of exchanges) {
-      sessionTokens.inputTokens += ex.tokenUsage.inputTokens;
-      sessionTokens.outputTokens += ex.tokenUsage.outputTokens;
-      sessionTokens.cacheReadTokens += ex.tokenUsage.cacheReadTokens;
-      sessionTokens.cacheCreationTokens += ex.tokenUsage.cacheCreationTokens;
-    }
-
-    sessions.push({
-      id: file.replace('.jsonl', ''),
-      file,
-      exchanges,
-      turnCount: turns.length,
-      exchangeCount: exchanges.length,
-      startTime: timestamps[0] ? new Date(timestamps[0]).toISOString() : null,
-      endTime: timestamps[timestamps.length - 1] ? new Date(timestamps[timestamps.length - 1]).toISOString() : null,
-      durationMinutes: timestamps.length >= 2
-        ? Math.round((timestamps[timestamps.length - 1] - timestamps[0]) / 60000)
-        : 0,
-      tokenUsage: sessionTokens,
-    });
-  }
-
-  return sessions;
-}
-
-/**
- * Parse all Claude Code projects.
- */
-export function parseAllProjects(basePath) {
-  const projects = readdirSync(basePath).filter(f => {
-    try {
-      return statSync(join(basePath, f)).isDirectory();
-    } catch {
-      return false;
-    }
-  });
-
-  const allSessions = [];
-
-  for (const project of projects) {
-    const projectPath = join(basePath, project);
-    const sessions = parseProject(projectPath);
-
-    for (const session of sessions) {
-      session.project = project.replace(/-/g, '/').replace(/^\//, '');
-      allSessions.push(session);
-    }
-  }
-
-  return allSessions;
-}