claude-cli-analytics 0.0.1

package/dist/server/config.js

@@ -0,0 +1,120 @@
+// ── Configuration management for Claude Analytics ──
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+const CONFIG_DIR = path.join(os.homedir(), '.claude-analytics');
+const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
+const DEFAULT_PROJECTS_DIR = path.join(os.homedir(), '.claude', 'projects');
+/**
+ * Load the application config from disk, or return defaults.
+ */
+export function loadConfig() {
+    try {
+        if (fs.existsSync(CONFIG_FILE)) {
+            const raw = fs.readFileSync(CONFIG_FILE, 'utf-8');
+            return JSON.parse(raw);
+        }
+    }
+    catch (err) {
+        console.error('Error loading config:', err);
+    }
+    return {
+        claude_projects_dir: '',
+        initialized: false
+    };
+}
+/**
+ * Save the application config to disk.
+ */
+export function saveConfig(config) {
+    try {
+        if (!fs.existsSync(CONFIG_DIR)) {
+            fs.mkdirSync(CONFIG_DIR, { recursive: true });
+        }
+        fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2), 'utf-8');
+    }
+    catch (err) {
+        console.error('Error saving config:', err);
+        throw err;
+    }
+}
+/**
+ * Resolve the Claude projects directory.
+ * Priority: env var > config file > auto-detect > default path.
+ * Auto-detection makes `init` unnecessary for most users.
+ */
+export function resolveProjectsDir() {
+    // 1. Environment variable (highest priority)
+    if (process.env.CLAUDE_PROJECTS_DIR) {
+        return process.env.CLAUDE_PROJECTS_DIR;
+    }
+    // 2. Saved config (user explicitly set via UI/API)
+    const config = loadConfig();
+    if (config.claude_projects_dir && config.initialized) {
+        return config.claude_projects_dir;
+    }
+    // 3. Auto-detect from common Claude Code installation paths
+    const detected = autoDetectProjectsDir();
+    if (detected.found) {
+        return detected.path;
+    }
+    // 4. Fallback to default
+    return DEFAULT_PROJECTS_DIR;
+}
+/**
+ * Check if a given path looks like a valid Claude projects directory.
+ * Claude projects dir contains subdirectories starting with '-' (hashed project paths).
+ */
+export function validateProjectsDir(dirPath) {
+    try {
+        if (!fs.existsSync(dirPath)) {
+            return { valid: false, projectCount: 0 };
+        }
+        const entries = fs.readdirSync(dirPath, { withFileTypes: true });
+        const projects = entries.filter(e => e.isDirectory() && e.name.startsWith('-'));
+        return { valid: projects.length > 0, projectCount: projects.length };
+    }
+    catch {
+        return { valid: false, projectCount: 0 };
+    }
+}
+/**
+ * Auto-detect Claude projects directory from all known locations.
+ *
+ * Claude Code stores session data at ~/.claude/projects regardless of
+ * installation method (homebrew, npm, direct install).
+ *
+ * We also check XDG-based and custom env var paths for edge cases.
+ */
+export function autoDetectProjectsDir() {
+    const home = os.homedir();
+    const candidates = [];
+    // Standard path — works for all installation methods
+    // (homebrew: brew install --cask claude-code)
+    // (npm: npm install -g @anthropic-ai/claude-code)
+    // (direct: downloaded binary)
+    candidates.push(path.join(home, '.claude', 'projects'));
+    // XDG config path (Linux users who set XDG_CONFIG_HOME)
+    const xdgConfigHome = process.env.XDG_CONFIG_HOME;
+    if (xdgConfigHome) {
+        candidates.push(path.join(xdgConfigHome, 'claude', 'projects'));
+    }
+    // Custom Claude config dir (if user has set CLAUDE_CONFIG_DIR)
+    const claudeConfigDir = process.env.CLAUDE_CONFIG_DIR;
+    if (claudeConfigDir) {
+        candidates.push(path.join(claudeConfigDir, 'projects'));
+    }
+    // Linux snap installation path
+    if (process.platform === 'linux') {
+        candidates.push(path.join(home, 'snap', 'claude', 'common', '.claude', 'projects'));
+    }
+    // Deduplicate
+    const uniqueCandidates = [...new Set(candidates)];
+    for (const candidate of uniqueCandidates) {
+        const result = validateProjectsDir(candidate);
+        if (result.valid) {
+            return { path: candidate, found: true };
+        }
+    }
+    return { path: DEFAULT_PROJECTS_DIR, found: false };
+}

package/dist/server/index.js

@@ -0,0 +1,151 @@
+// ── Claude Analytics Server — Entry Point ──
+// Routes + server startup only. All logic is in separate modules.
+import express from 'express';
+import cors from 'cors';
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { exec } from 'child_process';
+import { resolveProjectsDir, loadConfig, saveConfig, autoDetectProjectsDir, validateProjectsDir } from './config.js';
+import { getProjectsList } from './parser.js';
+import { getSessionsList, getSessionDetail, getAnalytics } from './analyzer.js';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const app = express();
+const PORT = parseInt(process.env.PORT || '3001', 10);
+app.use(cors());
+app.use(express.json());
+// ── Helper: resolve projects dir per-request ──
+function getProjectsDir() {
+    return resolveProjectsDir();
+}
+// ════════════════════════════════════════════════════════════
+// Config / Setup API (항목 1: Init 페이지)
+// ════════════════════════════════════════════════════════════
+app.get('/api/config', (_req, res) => {
+    const config = loadConfig();
+    const detected = autoDetectProjectsDir();
+    const resolvedPath = resolveProjectsDir();
+    const validation = validateProjectsDir(resolvedPath);
+    res.json({
+        ...config,
+        detected_path: detected.path,
+        detected: detected.found,
+        resolved_path: resolvedPath,
+        auto_detected: detected.found && !config.initialized,
+        ready: validation.valid,
+        projectCount: validation.projectCount
+    });
+});
+app.post('/api/config', (req, res) => {
+    try {
+        const { claude_projects_dir } = req.body;
+        if (!claude_projects_dir) {
+            return res.status(400).json({ error: 'claude_projects_dir is required' });
+        }
+        const validation = validateProjectsDir(claude_projects_dir);
+        if (!validation.valid) {
+            return res.status(400).json({
+                error: 'Invalid projects directory — no Claude project folders found',
+                path: claude_projects_dir
+            });
+        }
+        saveConfig({ claude_projects_dir, initialized: true });
+        res.json({ success: true, projectCount: validation.projectCount });
+    }
+    catch (err) {
+        res.status(500).json({ error: err.message });
+    }
+});
+// ════════════════════════════════════════════════════════════
+// Data API
+// ════════════════════════════════════════════════════════════
+app.get('/api/projects', (_req, res) => {
+    res.json(getProjectsList(getProjectsDir()));
+});
+app.get('/api/sessions', (req, res) => {
+    const projectPath = req.query.project;
+    const startDate = req.query.from;
+    const endDate = req.query.to;
+    res.json(getSessionsList(getProjectsDir(), projectPath, startDate, endDate));
+});
+app.get('/api/sessions/:id', (req, res) => {
+    const projectPath = req.query.project;
+    const detail = getSessionDetail(getProjectsDir(), req.params.id, projectPath);
+    if (!detail)
+        return res.status(404).json({ error: 'Session not found' });
+    res.json(detail);
+});
+app.get('/api/analytics', (req, res) => {
+    const projectPath = req.query.project;
+    const startDate = req.query.from;
+    const endDate = req.query.to;
+    res.json(getAnalytics(getProjectsDir(), projectPath, startDate, endDate));
+});
+app.get('/api/health', (_req, res) => {
+    res.json({ status: 'ok', uptime: process.uptime(), timestamp: new Date().toISOString() });
+});
+app.post('/api/refresh', (req, res) => {
+    const projectPath = req.body.project;
+    const analytics = getAnalytics(getProjectsDir(), projectPath);
+    res.json({ success: true, analytics });
+});
+// ════════════════════════════════════════════════════════════
+// Static file serving (SPA)
+// ════════════════════════════════════════════════════════════
+const distPath = path.resolve(__dirname, '../client');
+const indexHtmlPath = path.join(distPath, 'index.html');
+if (fs.existsSync(distPath)) {
+    app.use(express.static(distPath));
+    app.use((req, res, next) => {
+        if (req.path.startsWith('/api'))
+            return next();
+        res.sendFile(indexHtmlPath);
+    });
+    console.log(`📦 Serving frontend from: ${distPath}`);
+}
+else {
+    console.log(`⚠️  Frontend not found at: ${distPath}`);
+    console.log(`   Run in dev mode: npm run dev`);
+}
+// ════════════════════════════════════════════════════════════
+// Server startup
+// ════════════════════════════════════════════════════════════
+const server = app.listen(PORT, () => {
+    const url = `http://localhost:${PORT}`;
+    console.log(`\n  🔍 Claude Analytics Dashboard`);
+    console.log(`  ${url}\n`);
+    const projectsDir = getProjectsDir();
+    const detected = autoDetectProjectsDir();
+    if (detected.found) {
+        console.log(`  ✅ Auto-detected: ${projectsDir}`);
+    }
+    else if (process.env.CLAUDE_PROJECTS_DIR) {
+        console.log(`  📁 Using env var: ${projectsDir}`);
+    }
+    else {
+        console.log(`  ⚠️  Projects dir not found: ${projectsDir}`);
+        console.log(`     Set CLAUDE_PROJECTS_DIR or install Claude Code first.`);
+    }
+    try {
+        const projects = getProjectsList(projectsDir);
+        console.log(`  📊 Found ${projects.length} projects\n`);
+    }
+    catch {
+        console.log(`  📊 No projects found yet\n`);
+    }
+    const openCmd = process.platform === 'darwin' ? 'open' : process.platform === 'win32' ? 'start' : 'xdg-open';
+    exec(`${openCmd} ${url}`, (err) => {
+        if (err)
+            console.log(`  Open your browser at: ${url}`);
+    });
+});
+process.on('uncaughtException', (err) => {
+    console.error('Uncaught exception:', err);
+});
+process.on('unhandledRejection', (err) => {
+    console.error('Unhandled rejection:', err);
+});
+server.on('close', () => {
+    console.log('Server closed');
+});

package/dist/server/parser.js

@@ -0,0 +1,48 @@
+// ── JSONL file parsing and project discovery ──
+import fs from 'fs';
+import path from 'path';
+/**
+ * Parse a single JSONL file into an array of Message records.
+ */
+export function parseJsonlFile(filepath) {
+    const records = [];
+    try {
+        const content = fs.readFileSync(filepath, 'utf-8');
+        const lines = content.split('\n').filter(line => line.trim());
+        for (const line of lines) {
+            try {
+                records.push(JSON.parse(line));
+            }
+            catch {
+                continue;
+            }
+        }
+    }
+    catch (err) {
+        console.error(`Error reading ${filepath}:`, err);
+    }
+    return records;
+}
+/**
+ * Get sorted list of all projects from the Claude projects directory.
+ */
+export function getProjectsList(projectsDir) {
+    const projects = [];
+    if (!fs.existsSync(projectsDir)) {
+        console.error(`Projects directory not found: ${projectsDir}`);
+        return projects;
+    }
+    const entries = fs.readdirSync(projectsDir, { withFileTypes: true });
+    for (const entry of entries) {
+        if (entry.isDirectory() && entry.name.startsWith('-')) {
+            const projectPath = path.join(projectsDir, entry.name);
+            const jsonlFiles = fs.readdirSync(projectPath).filter(f => f.endsWith('.jsonl'));
+            projects.push({
+                name: entry.name.replace(/-/g, '/').slice(1),
+                path: entry.name,
+                session_count: jsonlFiles.length
+            });
+        }
+    }
+    return projects.sort((a, b) => b.session_count - a.session_count);
+}

package/dist/server/types.js

@@ -0,0 +1,2 @@
+// ── Shared type definitions for the Claude Analytics server ──
+export {};

package/package.json

@@ -0,0 +1,77 @@
+{
+  "name": "claude-cli-analytics",
+  "version": "0.0.1",
+  "description": "Claude CLI Analytics Dashboard - Efficiency insights for Claude Pro users",
+  "keywords": [
+    "claude",
+    "analytics",
+    "dashboard",
+    "cli",
+    "token-usage",
+    "claude-cli",
+    "tool-use",
+    "visualization"
+  ],
+  "homepage": "https://github.com/igeunpyo/claude-analytics#readme",
+  "bugs": {
+    "url": "https://github.com/igeunpyo/claude-analytics/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/igeunpyo/claude-analytics.git"
+  },
+  "license": "MIT",
+  "author": "GeunPyo Lee <igeunpyo@gmail.com>",
+  "main": "dist/server/index.js",
+  "type": "module",
+  "bin": {
+    "claude-cli-analytics": "./bin/cli.js"
+  },
+  "files": [
+    "dist",
+    "bin",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "dev": "concurrently \"npm run dev:server\" \"npm run dev:client\"",
+    "dev:client": "vite",
+    "dev:server": "npx tsx watch server/index.ts",
+    "build": "tsc -b && vite build && tsc -p tsconfig.server.json",
+    "preview": "vite preview",
+    "start": "node dist/server/index.js",
+    "lint": "eslint .",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "cors": "^2.8.6",
+    "express": "^5.2.1",
+    "react": "^19.2.0",
+    "react-dom": "^19.2.0",
+    "react-router-dom": "^7.13.0",
+    "recharts": "^3.7.0"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.39.1",
+    "@tailwindcss/vite": "^4.1.18",
+    "@types/cors": "^2.8.19",
+    "@types/express": "^5.0.6",
+    "@types/node": "^24.10.1",
+    "@types/react": "^19.2.7",
+    "@types/react-dom": "^19.2.3",
+    "@vitejs/plugin-react": "^5.1.1",
+    "concurrently": "^9.2.1",
+    "eslint": "^9.39.1",
+    "eslint-plugin-react-hooks": "^7.0.1",
+    "eslint-plugin-react-refresh": "^0.4.24",
+    "globals": "^16.5.0",
+    "tailwindcss": "^4.1.18",
+    "tsx": "^4.21.0",
+    "typescript": "~5.9.3",
+    "typescript-eslint": "^8.48.0",
+    "vite": "^7.3.1"
+  },
+  "engines": {
+    "node": ">=20.0.0"
+  }
+}