code-dash 1.0.0

package/README.md

@@ -0,0 +1,55 @@
+# ClaudeView
+
+A local analytics dashboard for your [Claude Code](https://claude.ai/code) sessions.
+
+Reads `~/.claude/` and shows you token usage, costs, tool activity, session history, and more — all in a clean browser dashboard.
+
+## Usage
+
+```bash
+npx claudeview
+```
+
+Then open http://localhost:3000 (it opens automatically).
+
+## Options
+
+```
+claudeview --port=3001    # use a different port
+claudeview --no-open      # don't auto-open the browser
+```
+
+## What it shows
+
+- **Token usage** — input, output, cache creation & reads over time
+- **Estimated cost** — per session and total, by model
+- **Model distribution** — which Claude models you use most
+- **Activity heatmap** — GitHub-style calendar of your activity
+- **Tool usage** — which tools (Bash, Read, Write, etc.) you call most
+- **Hourly distribution** — when in the day you're most active
+- **Cache efficiency** — your prompt cache hit rate
+- **Sessions table** — every session with duration, message counts, tokens, cost
+- **Projects table** — per-project rollup of all activity
+
+## Data sources
+
+All data is read locally from `~/.claude/`:
+
+| Source | Data |
+|--------|------|
+| `~/.claude/projects/**/*.jsonl` | Session conversations, token usage, tool calls |
+| `~/.claude.json` | Account info, project metadata |
+| `~/.claude/history.jsonl` | Command/input history |
+
+No data leaves your machine.
+
+## Install globally
+
+```bash
+npm install -g claudeview
+claudeview
+```
+
+## License
+
+MIT

package/bin/claudeview.js

@@ -0,0 +1,91 @@
+#!/usr/bin/env node
+'use strict';
+
+const http = require('http');
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+const { analyze } = require('../src/analyzer');
+
+const args = process.argv.slice(2);
+const portArg = args.find(a => a.startsWith('--port=') || a.startsWith('-p='));
+const PORT = portArg ? parseInt(portArg.split('=')[1]) : 3000;
+const noOpen = args.includes('--no-open');
+const DASHBOARD_PATH = path.join(__dirname, '../src/dashboard.html');
+
+const MIME = {
+  '.html': 'text/html',
+  '.json': 'application/json',
+  '.js':   'text/javascript',
+  '.css':  'text/css',
+};
+
+function openBrowser(url) {
+  try {
+    const platform = process.platform;
+    if (platform === 'darwin') execSync(`open "${url}"`, { stdio: 'ignore' });
+    else if (platform === 'win32') execSync(`start "" "${url}"`, { stdio: 'ignore', shell: true });
+    else execSync(`xdg-open "${url}"`, { stdio: 'ignore' });
+  } catch (_) {}
+}
+
+const server = http.createServer((req, res) => {
+  const url = req.url.split('?')[0];
+
+  // CORS for dev
+  res.setHeader('Access-Control-Allow-Origin', '*');
+
+  if (url === '/api/data') {
+    try {
+      const data = analyze();
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify(data));
+    } catch (err) {
+      res.writeHead(500, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ error: err.message }));
+    }
+    return;
+  }
+
+  // Serve dashboard
+  if (url === '/' || url === '/index.html') {
+    try {
+      const html = fs.readFileSync(DASHBOARD_PATH, 'utf8');
+      res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
+      res.end(html);
+    } catch (err) {
+      res.writeHead(500);
+      res.end(`<pre>Error loading dashboard: ${err.message}</pre>`);
+    }
+    return;
+  }
+
+  res.writeHead(404);
+  res.end('Not found');
+});
+
+server.listen(PORT, '127.0.0.1', () => {
+  const url = `http://localhost:${PORT}`;
+  console.log('\n  ClaudeView  ');
+  console.log('  ─────────────────────────────────────');
+  console.log(`  Dashboard  →  ${url}`);
+  console.log(`  API data   →  ${url}/api/data`);
+  console.log('  ─────────────────────────────────────');
+  console.log('  Press Ctrl+C to stop\n');
+
+  if (!noOpen) openBrowser(url);
+});
+
+server.on('error', (err) => {
+  if (err.code === 'EADDRINUSE') {
+    console.error(`\n  Port ${PORT} is already in use. Try: claudeview --port=3001\n`);
+  } else {
+    console.error('\n  Server error:', err.message, '\n');
+  }
+  process.exit(1);
+});
+
+process.on('SIGINT', () => {
+  console.log('\n  Goodbye!\n');
+  process.exit(0);
+});

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "code-dash",
+  "version": "1.0.0",
+  "description": "Analytics dashboard for your local Claude Code sessions — token usage, activity, and costs.",
+  "type": "module",
+  "bin": {
+    "code-dash": "bin/claudeview.js"
+  },
+  "main": "src/analyzer.js",
+  "scripts": {
+    "start": "node bin/claudeview.js"
+  },
+  "keywords": [
+    "claude",
+    "claude-code",
+    "anthropic",
+    "ai",
+    "analytics",
+    "dashboard",
+    "npx"
+  ],
+  "author": "Hari Govind <harigovind2102@gmail.com>",
+  "license": "MIT",
+  "preferGlobal": true,
+  "engines": {
+    "node": ">=16.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/harigovind511/claudeview.git"
+  },
+  "files": [
+    "bin/",
+    "src/",
+    "README.md"
+  ]
+}

package/src/analyzer.js

@@ -0,0 +1,389 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const CLAUDE_DIR = path.join(os.homedir(), '.claude');
+const CLAUDE_CONFIG = path.join(os.homedir(), '.claude.json');
+
+// Approximate cost per million tokens (USD) by model
+const MODEL_COSTS = {
+  'claude-opus-4':               { input: 15,   output: 75,   cacheWrite: 18.75, cacheRead: 1.50 },
+  'claude-opus-4-5':             { input: 15,   output: 75,   cacheWrite: 18.75, cacheRead: 1.50 },
+  'claude-sonnet-4-5':           { input: 3,    output: 15,   cacheWrite: 3.75,  cacheRead: 0.30 },
+  'claude-sonnet-4-6':           { input: 3,    output: 15,   cacheWrite: 3.75,  cacheRead: 0.30 },
+  'claude-haiku-4-5':            { input: 0.80, output: 4,    cacheWrite: 1.00,  cacheRead: 0.08 },
+  'claude-haiku-4-5-20251001':   { input: 0.80, output: 4,    cacheWrite: 1.00,  cacheRead: 0.08 },
+  'claude-sonnet-3-5':           { input: 3,    output: 15,   cacheWrite: 3.75,  cacheRead: 0.30 },
+  'claude-haiku-3':              { input: 0.25, output: 1.25, cacheWrite: 0.30,  cacheRead: 0.03 },
+};
+
+function getModelCost(model) {
+  if (!model) return { input: 3, output: 15, cacheWrite: 3.75, cacheRead: 0.30 };
+  // Exact match first
+  if (MODEL_COSTS[model]) return MODEL_COSTS[model];
+  // Prefix match
+  for (const key of Object.keys(MODEL_COSTS)) {
+    if (model.startsWith(key) || key.startsWith(model)) return MODEL_COSTS[key];
+  }
+  return { input: 3, output: 15, cacheWrite: 3.75, cacheRead: 0.30 };
+}
+
+function calcCost(usage, model) {
+  const rates = getModelCost(model);
+  const M = 1_000_000;
+  return (
+    ((usage.input_tokens || 0) * rates.input) / M +
+    ((usage.output_tokens || 0) * rates.output) / M +
+    ((usage.cache_creation_input_tokens || 0) * rates.cacheWrite) / M +
+    ((usage.cache_read_input_tokens || 0) * rates.cacheRead) / M
+  );
+}
+
+function parseJSONL(filePath) {
+  try {
+    const content = fs.readFileSync(filePath, 'utf8');
+    const results = [];
+    for (const line of content.split('\n')) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      try {
+        results.push(JSON.parse(trimmed));
+      } catch (_) {
+        // skip malformed lines
+      }
+    }
+    return results;
+  } catch (_) {
+    return [];
+  }
+}
+
+function readConfig() {
+  try {
+    const raw = fs.readFileSync(CLAUDE_CONFIG, 'utf8');
+    return JSON.parse(raw);
+  } catch (_) {
+    return null;
+  }
+}
+
+function getProjectName(projectPath) {
+  if (!projectPath) return 'Unknown';
+  const parts = projectPath.replace(/\\/g, '/').split('/').filter(Boolean);
+  return parts.slice(-2).join('/') || parts[parts.length - 1] || projectPath;
+}
+
+function formatDirName(dirName) {
+  // "-Users-hari-Code-Base-Open-Source-claudeview" -> "/Users/hari/Code Base/Open Source/claudeview"
+  return '/' + dirName.replace(/-+/g, (m, offset, str) => {
+    // heuristic: keep hyphen if it looks like a word-hyphen (e.g. "Open-Source")
+    // but replace leading/separator hyphens with /
+    return '/';
+  }).replace(/^\/+/, '/');
+}
+
+function resolveProjectPath(dirName) {
+  // Best-effort: replace - with / to recover original path
+  // The dir names use - as separator: "-Users-hari-Foo" -> "/Users/hari/Foo"
+  // But paths with spaces become "-Users-hari-Code-Base-Foo" which loses space info
+  return dirName.replace(/^-/, '/').replace(/-/g, '/');
+}
+
+function analyze() {
+  const config = readConfig();
+  const projectsDir = path.join(CLAUDE_DIR, 'projects');
+
+  // ── Account info ─────────────────────────────────────────────────────────
+  let account = { email: null, organization: null, subscriptionType: null };
+  if (config?.oauthAccount) {
+    account = {
+      email: config.oauthAccount.emailAddress || null,
+      organization: config.oauthAccount.organizationName || null,
+      subscriptionType: config.oauthAccount.accountType || null,
+      userId: config.oauthAccount.userId || null,
+    };
+  }
+
+  // ── Session files ─────────────────────────────────────────────────────────
+  const sessions = [];
+  const toolUsage = {};
+  const modelUsage = {};
+  const dailyMap = {};      // date -> { messages, tokens, cost, sessions }
+  const hourlyDist = new Array(24).fill(0);
+
+  let totalInputTokens = 0;
+  let totalOutputTokens = 0;
+  let totalCacheCreation = 0;
+  let totalCacheRead = 0;
+  let totalCostUSD = 0;
+  let totalUserMessages = 0;
+  let totalAssistantMessages = 0;
+  let totalToolCalls = 0;
+
+  if (fs.existsSync(projectsDir)) {
+    const projectDirs = fs.readdirSync(projectsDir).filter(d => {
+      return fs.statSync(path.join(projectsDir, d)).isDirectory();
+    });
+
+    for (const projDir of projectDirs) {
+      const projPath = path.join(projectsDir, projDir);
+      const projectFullPath = resolveProjectPath(projDir);
+
+      const sessionFiles = fs.readdirSync(projPath)
+        .filter(f => f.endsWith('.jsonl') && !fs.statSync(path.join(projPath, f)).isDirectory());
+
+      for (const sessionFile of sessionFiles) {
+        const sessionId = sessionFile.replace('.jsonl', '');
+        const lines = parseJSONL(path.join(projPath, sessionFile));
+
+        if (lines.length === 0) continue;
+
+        // per-session aggregates
+        let sInputTokens = 0, sOutputTokens = 0, sCacheCreation = 0, sCacheRead = 0;
+        let sUserMessages = 0, sAssistantMessages = 0, sToolCalls = 0;
+        let sModel = null;
+        let sStartTime = null, sEndTime = null;
+        const sTools = {};
+
+        for (const line of lines) {
+          if (!line.timestamp) continue;
+          const ts = new Date(line.timestamp);
+          if (isNaN(ts.getTime())) continue;
+
+          if (!sStartTime || ts < sStartTime) sStartTime = ts;
+          if (!sEndTime   || ts > sEndTime)   sEndTime   = ts;
+
+          if (line.type === 'user') {
+            sUserMessages++;
+            // Count hour distribution
+            hourlyDist[ts.getHours()]++;
+          }
+
+          if (line.type === 'assistant' && line.message) {
+            sAssistantMessages++;
+            const msg = line.message;
+            const model = msg.model || line.model || null;
+            if (model && !sModel) sModel = model;
+
+            // Token usage
+            const usage = msg.usage || {};
+            const inp  = usage.input_tokens || 0;
+            const out  = usage.output_tokens || 0;
+            const cc   = usage.cache_creation_input_tokens || 0;
+            const cr   = usage.cache_read_input_tokens || 0;
+
+            sInputTokens  += inp;
+            sOutputTokens += out;
+            sCacheCreation += cc;
+            sCacheRead    += cr;
+
+            const cost = calcCost(usage, model);
+            totalCostUSD += cost;
+
+            // Model usage
+            if (model) {
+              if (!modelUsage[model]) modelUsage[model] = { messages: 0, inputTokens: 0, outputTokens: 0, cost: 0 };
+              modelUsage[model].messages++;
+              modelUsage[model].inputTokens  += inp;
+              modelUsage[model].outputTokens += out;
+              modelUsage[model].cost         += cost;
+            }
+
+            // Tool calls in content
+            if (Array.isArray(msg.content)) {
+              for (const block of msg.content) {
+                if (block.type === 'tool_use') {
+                  sToolCalls++;
+                  const tName = block.name || 'unknown';
+                  sTools[tName] = (sTools[tName] || 0) + 1;
+                  toolUsage[tName] = (toolUsage[tName] || 0) + 1;
+                }
+              }
+            }
+
+            // Daily map
+            const dateKey = ts.toISOString().slice(0, 10);
+            if (!dailyMap[dateKey]) dailyMap[dateKey] = { messages: 0, tokens: 0, cost: 0, sessions: new Set() };
+            dailyMap[dateKey].messages++;
+            dailyMap[dateKey].tokens += inp + out;
+            dailyMap[dateKey].cost   += cost;
+            dailyMap[dateKey].sessions.add(sessionId);
+          }
+        }
+
+        // Accumulate totals
+        totalInputTokens  += sInputTokens;
+        totalOutputTokens += sOutputTokens;
+        totalCacheCreation += sCacheCreation;
+        totalCacheRead    += sCacheRead;
+        totalUserMessages += sUserMessages;
+        totalAssistantMessages += sAssistantMessages;
+        totalToolCalls    += sToolCalls;
+
+        const durationMs = sStartTime && sEndTime ? sEndTime - sStartTime : 0;
+        const sessionCost = calcCost({
+          input_tokens: sInputTokens,
+          output_tokens: sOutputTokens,
+          cache_creation_input_tokens: sCacheCreation,
+          cache_read_input_tokens: sCacheRead,
+        }, sModel);
+
+        sessions.push({
+          id: sessionId,
+          project: projectFullPath,
+          projectName: getProjectName(projectFullPath),
+          startTime: sStartTime ? sStartTime.toISOString() : null,
+          endTime: sEndTime ? sEndTime.toISOString() : null,
+          durationMinutes: Math.round(durationMs / 60000),
+          messages: sUserMessages + sAssistantMessages,
+          userMessages: sUserMessages,
+          assistantMessages: sAssistantMessages,
+          tokens: {
+            input: sInputTokens,
+            output: sOutputTokens,
+            cacheCreation: sCacheCreation,
+            cacheRead: sCacheRead,
+            total: sInputTokens + sOutputTokens + sCacheCreation + sCacheRead,
+          },
+          costUSD: sessionCost,
+          model: sModel,
+          toolCalls: sToolCalls,
+          topTools: Object.entries(sTools)
+            .sort((a, b) => b[1] - a[1])
+            .slice(0, 5)
+            .map(([name, count]) => ({ name, count })),
+        });
+      }
+    }
+  }
+
+  // Sort sessions by startTime desc
+  sessions.sort((a, b) => {
+    if (!a.startTime) return 1;
+    if (!b.startTime) return -1;
+    return b.startTime.localeCompare(a.startTime);
+  });
+
+  // ── Projects rollup ───────────────────────────────────────────────────────
+  const projectMap = {};
+  for (const s of sessions) {
+    const key = s.project;
+    if (!projectMap[key]) {
+      projectMap[key] = {
+        path: s.project,
+        name: s.projectName,
+        sessions: 0,
+        messages: 0,
+        tokens: { input: 0, output: 0, cacheCreation: 0, cacheRead: 0, total: 0 },
+        costUSD: 0,
+        lastActive: null,
+        tools: {},
+      };
+    }
+    const p = projectMap[key];
+    p.sessions++;
+    p.messages += s.messages;
+    p.tokens.input        += s.tokens.input;
+    p.tokens.output       += s.tokens.output;
+    p.tokens.cacheCreation += s.tokens.cacheCreation;
+    p.tokens.cacheRead    += s.tokens.cacheRead;
+    p.tokens.total        += s.tokens.total;
+    p.costUSD             += s.costUSD;
+    if (!p.lastActive || (s.startTime && s.startTime > p.lastActive)) {
+      p.lastActive = s.startTime;
+    }
+    for (const { name, count } of s.topTools) {
+      p.tools[name] = (p.tools[name] || 0) + count;
+    }
+  }
+
+  // Also pull cost data from config's project metadata (more accurate)
+  if (config?.projects) {
+    for (const [projPath, meta] of Object.entries(config.projects)) {
+      const key = projPath;
+      if (projectMap[key] && meta.lastCost) {
+        // Use config cost if we have it (it's the authoritative source)
+        // but only if our calculated cost is zero (no session data)
+        if (projectMap[key].costUSD === 0 && meta.lastCost) {
+          projectMap[key].costUSD = meta.lastCost;
+        }
+      }
+    }
+  }
+
+  const projects = Object.values(projectMap)
+    .sort((a, b) => (b.lastActive || '').localeCompare(a.lastActive || ''));
+
+  // ── Daily activity ────────────────────────────────────────────────────────
+  const dailyActivity = Object.entries(dailyMap)
+    .map(([date, d]) => ({
+      date,
+      messages: d.messages,
+      tokens: d.tokens,
+      cost: d.cost,
+      sessions: d.sessions.size,
+    }))
+    .sort((a, b) => a.date.localeCompare(b.date));
+
+  // ── Date range ────────────────────────────────────────────────────────────
+  const allDates = sessions.filter(s => s.startTime).map(s => s.startTime);
+  const firstDate = allDates.length ? allDates[allDates.length - 1] : null;
+  const lastDate  = allDates.length ? allDates[0] : null;
+
+  const totalTokens = totalInputTokens + totalOutputTokens + totalCacheCreation + totalCacheRead;
+  const cacheHitRate = totalTokens > 0
+    ? Math.round((totalCacheRead / totalTokens) * 100)
+    : 0;
+
+  // ── Command history ───────────────────────────────────────────────────────
+  const historyPath = path.join(CLAUDE_DIR, 'history.jsonl');
+  const history = parseJSONL(historyPath)
+    .filter(h => h.display)
+    .slice(-100)
+    .map(h => ({
+      display: h.display,
+      timestamp: h.timestamp,
+      project: h.project || null,
+      sessionId: h.sessionId || null,
+    }));
+
+  return {
+    meta: {
+      analyzedAt: new Date().toISOString(),
+      claudeDir: CLAUDE_DIR,
+      version: '1.0.0',
+    },
+    account,
+    overview: {
+      totalSessions: sessions.length,
+      totalProjects: projects.length,
+      totalMessages: { user: totalUserMessages, assistant: totalAssistantMessages, total: totalUserMessages + totalAssistantMessages },
+      tokens: {
+        input: totalInputTokens,
+        output: totalOutputTokens,
+        cacheCreation: totalCacheCreation,
+        cacheRead: totalCacheRead,
+        total: totalTokens,
+        cacheHitRate,
+      },
+      costUSD: totalCostUSD,
+      toolCalls: totalToolCalls,
+      dateRange: {
+        first: firstDate,
+        last: lastDate,
+        activeDays: dailyActivity.length,
+      },
+    },
+    models: modelUsage,
+    projects,
+    sessions: sessions.slice(0, 200), // cap for JSON size
+    tools: toolUsage,
+    dailyActivity,
+    hourlyDistribution: hourlyDist,
+    recentHistory: history,
+  };
+}
+
+module.exports = { analyze };