ccanalyzer 1.0.0

package/bin/index.js

@@ -0,0 +1,16 @@
+#!/usr/bin/env node
+
+const { startServer } = require('../src/server');
+
+const port = parseInt(process.env.PORT || '3737', 10);
+
+startServer(port).then(({ url }) => {
+  console.log(`\n  ccanalyser running at ${url}\n`);
+  try {
+    // Try to open browser
+    import('open').then(m => m.default(url)).catch(() => {});
+  } catch {}
+}).catch(err => {
+  console.error('Failed to start server:', err.message);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "ccanalyzer",
+  "version": "1.0.0",
+  "description": "Web-based analyzer for Claude Code sessions",
+  "bin": {
+    "ccanalyzer": "./bin/index.js"
+  },
+  "main": "./src/server.js",
+  "scripts": {
+    "start": "node bin/index.js"
+  },
+  "files": [
+    "bin/",
+    "src/"
+  ],
+  "dependencies": {
+    "express": "^4.18.2",
+    "open": "^9.1.0"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "keywords": ["claude", "claude-code", "analytics", "sessions", "ccanalyzer"],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/olivier-j/ccanalyzer.git"
+  },
+  "homepage": "https://github.com/olivier-j/ccanalyzer"
+}

package/src/parser.js

@@ -0,0 +1,316 @@
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const CLAUDE_DIR = process.env.CLAUDE_CONFIG_DIR || path.join(os.homedir(), '.claude');
+const PROJECTS_DIR = path.join(CLAUDE_DIR, 'projects');
+
+const MODEL_PRICING = {
+  'claude-opus-4': { input: 15, output: 75, cache_write: 18.75, cache_read: 1.5 },
+  'claude-opus-3': { input: 15, output: 75, cache_write: 18.75, cache_read: 1.5 },
+  'claude-sonnet-4': { input: 3, output: 15, cache_write: 3.75, cache_read: 0.3 },
+  'claude-sonnet-3-7': { input: 3, output: 15, cache_write: 3.75, cache_read: 0.3 },
+  'claude-sonnet-3-5': { input: 3, output: 15, cache_write: 3.75, cache_read: 0.3 },
+  'claude-haiku-4': { input: 0.8, output: 4, cache_write: 1.0, cache_read: 0.08 },
+  'claude-haiku-3': { input: 0.25, output: 1.25, cache_write: 0.3, cache_read: 0.03 },
+};
+
+function getPricing(model) {
+  if (!model) return null;
+  for (const [key, p] of Object.entries(MODEL_PRICING)) {
+    if (model.startsWith(key)) return p;
+  }
+  return { input: 3, output: 15, cache_write: 3.75, cache_read: 0.3 };
+}
+
+function calcCost(usage, model) {
+  const p = getPricing(model);
+  if (!p) return 0;
+  const M = 1_000_000;
+  return (
+    (usage.input_tokens || 0) * p.input / M +
+    (usage.output_tokens || 0) * p.output / M +
+    (usage.cache_creation_input_tokens || 0) * p.cache_write / M +
+    (usage.cache_read_input_tokens || 0) * p.cache_read / M
+  );
+}
+
+function decodePath(dirName) {
+  return '/' + dirName.replace(/^-/, '').split('-').join('/');
+}
+
+function decodeProjectName(dirName) {
+  const full = decodePath(dirName);
+  const parts = full.split('/').filter(Boolean);
+  return parts[parts.length - 1] || full;
+}
+
+function parseLines(filePath) {
+  try {
+    return fs.readFileSync(filePath, 'utf8').trim().split('\n')
+      .filter(Boolean).map(l => { try { return JSON.parse(l); } catch { return null; } })
+      .filter(Boolean);
+  } catch { return []; }
+}
+
+function parseSessionFile(filePath, lightMode = false) {
+  const entries = parseLines(filePath);
+  const messages = [];
+  let title = null;
+  let sessionId = null;
+  let firstTimestamp = null;
+  let lastTimestamp = null;
+  const totalUsage = { input: 0, output: 0, cache_write: 0, cache_read: 0 };
+  let totalCost = 0;
+  let model = null;
+  let cwd = null;
+  let gitBranch = null;
+  let mainAgentMessages = 0;
+  let subAgentMessages = 0;
+  // Map toolUseId → { timestamp, uuid } for agent spawn detection
+  const toolUseMap = {};
+
+  for (const entry of entries) {
+    if (!sessionId && entry.sessionId) sessionId = entry.sessionId;
+    if (!cwd && entry.cwd) cwd = entry.cwd;
+    if (!gitBranch && entry.gitBranch) gitBranch = entry.gitBranch;
+
+    if (entry.type === 'ai-title') { title = entry.aiTitle; continue; }
+
+    if (entry.type === 'user' || entry.type === 'assistant') {
+      const ts = entry.timestamp ? new Date(entry.timestamp) : null;
+      if (ts) {
+        if (!firstTimestamp || ts < firstTimestamp) firstTimestamp = ts;
+        if (!lastTimestamp || ts > lastTimestamp) lastTimestamp = ts;
+      }
+
+      if (entry.type === 'assistant') {
+        const msg = entry.message || {};
+        if (msg.model && msg.model !== '<synthetic>') model = msg.model;
+        const usage = msg.usage;
+        if (usage) {
+          totalUsage.input += usage.input_tokens || 0;
+          totalUsage.output += usage.output_tokens || 0;
+          totalUsage.cache_write += usage.cache_creation_input_tokens || 0;
+          totalUsage.cache_read += usage.cache_read_input_tokens || 0;
+          totalCost += calcCost(usage, msg.model || model);
+        }
+        // Index tool_use IDs → for linking to spawned agents
+        if (!lightMode && Array.isArray(msg.content)) {
+          for (const block of msg.content) {
+            if (block && block.type === 'tool_use' && block.id) {
+              toolUseMap[block.id] = { timestamp: entry.timestamp, uuid: entry.uuid };
+            }
+          }
+        }
+      }
+
+      if (entry.isSidechain) subAgentMessages++;
+      else mainAgentMessages++;
+
+      if (!lightMode) {
+        messages.push({
+          uuid: entry.uuid,
+          parentUuid: entry.parentUuid,
+          type: entry.type,
+          timestamp: entry.timestamp,
+          isSidechain: entry.isSidechain || false,
+          content: entry.type === 'user'
+            ? (entry.message?.content || '')
+            : (entry.message?.content || []),
+          usage: entry.message?.usage || null,
+          model: entry.message?.model || null,
+          stopReason: entry.message?.stop_reason || null,
+        });
+      }
+    }
+  }
+
+  return {
+    sessionId,
+    title: title || 'Session sans titre',
+    cwd,
+    gitBranch,
+    model,
+    firstTimestamp: firstTimestamp?.toISOString() || null,
+    lastTimestamp: lastTimestamp?.toISOString() || null,
+    messageCount: lightMode ? (mainAgentMessages + subAgentMessages) : messages.length,
+    mainAgentMessages,
+    subAgentMessages,
+    totalUsage,
+    totalCost,
+    messages: lightMode ? [] : messages,
+    toolUseMap: lightMode ? {} : toolUseMap,
+  };
+}
+
+function parseAgentFile(filePath) {
+  return parseSessionFile(filePath, true);
+}
+
+function parseSubagents(sessionDir) {
+  const subagentsDir = path.join(sessionDir, 'subagents');
+  if (!fs.existsSync(subagentsDir)) return [];
+
+  const metaFiles = fs.readdirSync(subagentsDir).filter(f => f.endsWith('.meta.json'));
+  const agents = [];
+
+  for (const metaFile of metaFiles) {
+    const agentId = metaFile.replace('.meta.json', '');
+    const jsonlPath = path.join(subagentsDir, agentId + '.jsonl');
+    if (!fs.existsSync(jsonlPath)) continue;
+
+    let meta = {};
+    try { meta = JSON.parse(fs.readFileSync(path.join(subagentsDir, metaFile), 'utf8')); } catch {}
+
+    const parsed = parseAgentFile(jsonlPath);
+    agents.push({
+      agentId,
+      meta,
+      firstTimestamp: parsed.firstTimestamp,
+      lastTimestamp: parsed.lastTimestamp,
+      messageCount: parsed.messageCount,
+      totalUsage: parsed.totalUsage,
+      totalCost: parsed.totalCost,
+      model: parsed.model,
+    });
+  }
+
+  // Sort by start time
+  agents.sort((a, b) => {
+    const ta = a.firstTimestamp ? new Date(a.firstTimestamp) : new Date(0);
+    const tb = b.firstTimestamp ? new Date(b.firstTimestamp) : new Date(0);
+    return ta - tb;
+  });
+
+  return agents;
+}
+
+function getAllProjects() {
+  if (!fs.existsSync(PROJECTS_DIR)) return [];
+
+  const projectDirs = fs.readdirSync(PROJECTS_DIR).filter(d => {
+    return fs.statSync(path.join(PROJECTS_DIR, d)).isDirectory();
+  });
+
+  const projects = [];
+  for (const dirName of projectDirs) {
+    const projectPath = path.join(PROJECTS_DIR, dirName);
+    const sessionFiles = fs.readdirSync(projectPath).filter(f => f.endsWith('.jsonl'));
+    if (sessionFiles.length === 0) continue;
+
+    let totalCost = 0;
+    let totalMessages = 0;
+    let lastActivity = null;
+    let firstActivity = null;
+    const totalUsage = { input: 0, output: 0, cache_write: 0, cache_read: 0 };
+    const sessions = [];
+
+    for (const sf of sessionFiles) {
+      try {
+        const session = parseSessionFile(path.join(projectPath, sf), true);
+        totalCost += session.totalCost;
+        totalMessages += session.messageCount;
+        totalUsage.input += session.totalUsage.input;
+        totalUsage.output += session.totalUsage.output;
+        totalUsage.cache_write += session.totalUsage.cache_write;
+        totalUsage.cache_read += session.totalUsage.cache_read;
+
+        if (session.lastTimestamp) {
+          const d = new Date(session.lastTimestamp);
+          if (!lastActivity || d > new Date(lastActivity)) lastActivity = session.lastTimestamp;
+        }
+        if (session.firstTimestamp) {
+          const d = new Date(session.firstTimestamp);
+          if (!firstActivity || d < new Date(firstActivity)) firstActivity = session.firstTimestamp;
+        }
+
+        // Check if this session has subagents
+        const sessionId = sf.replace('.jsonl', '');
+        const sessionDir = path.join(projectPath, sessionId);
+        const hasSubagents = fs.existsSync(path.join(sessionDir, 'subagents'));
+
+        sessions.push({
+          sessionId: session.sessionId || sessionId,
+          file: sf,
+          title: session.title,
+          cwd: session.cwd,
+          gitBranch: session.gitBranch,
+          model: session.model,
+          firstTimestamp: session.firstTimestamp,
+          lastTimestamp: session.lastTimestamp,
+          messageCount: session.messageCount,
+          mainAgentMessages: session.mainAgentMessages,
+          subAgentMessages: session.subAgentMessages,
+          totalUsage: session.totalUsage,
+          totalCost: session.totalCost,
+          hasSubagents,
+        });
+      } catch {}
+    }
+
+    sessions.sort((a, b) => {
+      const da = a.lastTimestamp ? new Date(a.lastTimestamp) : new Date(0);
+      const db = b.lastTimestamp ? new Date(b.lastTimestamp) : new Date(0);
+      return db - da;
+    });
+
+    projects.push({
+      dirName,
+      name: decodeProjectName(dirName),
+      path: decodePath(dirName),
+      sessionCount: sessions.length,
+      totalMessages,
+      totalCost,
+      totalUsage,
+      firstActivity,
+      lastActivity,
+      sessions,
+    });
+  }
+
+  projects.sort((a, b) => {
+    const da = a.lastActivity ? new Date(a.lastActivity) : new Date(0);
+    const db = b.lastActivity ? new Date(b.lastActivity) : new Date(0);
+    return db - da;
+  });
+
+  return projects;
+}
+
+function getSessionDetail(dirName, sessionFile) {
+  const filePath = path.join(PROJECTS_DIR, dirName, sessionFile);
+  if (!fs.existsSync(filePath)) throw new Error('Session not found');
+
+  const session = parseSessionFile(filePath, false);
+
+  // Load subagents if the session directory exists
+  const sessionId = sessionFile.replace('.jsonl', '');
+  const sessionDir = path.join(PROJECTS_DIR, dirName, sessionId);
+  const agents = fs.existsSync(sessionDir) ? parseSubagents(sessionDir) : [];
+
+  // Link each agent to its spawn event in main session via toolUseId
+  for (const agent of agents) {
+    if (agent.meta.toolUseId && session.toolUseMap[agent.meta.toolUseId]) {
+      agent.spawnedAt = session.toolUseMap[agent.meta.toolUseId].timestamp;
+      agent.spawnedByUuid = session.toolUseMap[agent.meta.toolUseId].uuid;
+    }
+  }
+
+  return { ...session, agents };
+}
+
+function getAgentDetail(dirName, sessionFile, agentId) {
+  const sessionId = sessionFile.replace('.jsonl', '');
+  const agentPath = path.join(PROJECTS_DIR, dirName, sessionId, 'subagents', agentId + '.jsonl');
+  if (!fs.existsSync(agentPath)) throw new Error('Agent not found');
+  return parseSessionFile(agentPath, false);
+}
+
+function getStatsCache() {
+  const statsFile = path.join(CLAUDE_DIR, 'stats-cache.json');
+  if (!fs.existsSync(statsFile)) return null;
+  try { return JSON.parse(fs.readFileSync(statsFile, 'utf8')); } catch { return null; }
+}
+
+module.exports = { getAllProjects, getSessionDetail, getAgentDetail, getStatsCache, calcCost };