agentfit 0.1.0

package/lib/parse-logs.ts

@@ -0,0 +1,369 @@
+import fs from 'fs'
+import path from 'path'
+import os from 'os'
+import { loadPricing, calculateCost, type ModelPricing } from './pricing'
+
+const CLAUDE_DIR = path.join(os.homedir(), '.claude')
+const PROJECTS_DIR = path.join(CLAUDE_DIR, 'projects')
+
+// ─── Types ───────────────────────────────────────────────────────────
+
+export interface SessionSummary {
+  sessionId: string
+  project: string
+  projectPath: string // original path decoded from dir name
+  startTime: string
+  endTime: string
+  durationMinutes: number
+  userMessages: number
+  assistantMessages: number
+  totalMessages: number
+  inputTokens: number
+  outputTokens: number
+  cacheCreationTokens: number
+  cacheReadTokens: number
+  totalTokens: number
+  costUSD: number
+  model: string
+  toolCalls: Record<string, number>
+  toolCallsTotal: number
+}
+
+export interface ProjectSummary {
+  name: string
+  path: string
+  sessions: number
+  totalMessages: number
+  totalTokens: number
+  totalCost: number
+  totalDurationMinutes: number
+  toolCalls: Record<string, number>
+}
+
+export interface DailyUsage {
+  date: string
+  sessions: number
+  messages: number
+  inputTokens: number
+  outputTokens: number
+  cacheCreationTokens: number
+  cacheReadTokens: number
+  totalTokens: number
+  costUSD: number
+  toolCalls: number
+}
+
+export interface OverviewStats {
+  totalSessions: number
+  totalProjects: number
+  totalMessages: number
+  totalUserMessages: number
+  totalAssistantMessages: number
+  totalInputTokens: number
+  totalOutputTokens: number
+  totalCacheCreationTokens: number
+  totalCacheReadTokens: number
+  totalTokens: number
+  totalCostUSD: number
+  totalDurationMinutes: number
+  totalToolCalls: number
+  models: Record<string, number>
+}
+
+export interface UsageData {
+  overview: OverviewStats
+  sessions: SessionSummary[]
+  projects: ProjectSummary[]
+  daily: DailyUsage[]
+  toolUsage: Record<string, number>
+}
+
+// ─── Parsing ─────────────────────────────────────────────────────────
+
+function decodeProjectPath(dirName: string): string {
+  return dirName.replace(/-/g, '/')
+}
+
+function getProjectName(projectPath: string): string {
+  const parts = projectPath.split('/')
+  return parts[parts.length - 1] || parts[parts.length - 2] || projectPath
+}
+
+interface LogEntry {
+  type?: string
+  message?: {
+    role?: string
+    content?: unknown[]
+    model?: string
+    usage?: {
+      input_tokens?: number
+      output_tokens?: number
+      cache_creation_input_tokens?: number
+      cache_read_input_tokens?: number
+    }
+  }
+  timestamp?: string
+  uuid?: string
+}
+
+function parseSessionFile(
+  filePath: string,
+  allPricing: Record<string, ModelPricing>
+): SessionSummary | null {
+  try {
+    const content = fs.readFileSync(filePath, 'utf-8')
+    const lines = content.trim().split('\n')
+
+    let userMessages = 0
+    let assistantMessages = 0
+    let inputTokens = 0
+    let outputTokens = 0
+    let cacheCreationTokens = 0
+    let cacheReadTokens = 0
+    let costUSD = 0
+    let model = ''
+    let startTime = ''
+    let endTime = ''
+    const toolCalls: Record<string, number> = {}
+
+    for (const line of lines) {
+      if (!line.trim()) continue
+      let entry: LogEntry
+      try {
+        entry = JSON.parse(line)
+      } catch {
+        continue
+      }
+
+      // Track timestamps
+      if (entry.timestamp) {
+        if (!startTime) startTime = entry.timestamp
+        endTime = entry.timestamp
+      }
+
+      if (entry.type === 'user') {
+        userMessages++
+      } else if (entry.type === 'assistant' && entry.message) {
+        assistantMessages++
+        const msg = entry.message
+
+        // Model
+        if (msg.model && msg.model !== '<synthetic>') {
+          model = msg.model
+        }
+
+        // Usage
+        if (msg.usage) {
+          const u = msg.usage
+          inputTokens += u.input_tokens || 0
+          outputTokens += u.output_tokens || 0
+          cacheCreationTokens += u.cache_creation_input_tokens || 0
+          cacheReadTokens += u.cache_read_input_tokens || 0
+
+          if (model) {
+            costUSD += calculateCost(model, u, allPricing)
+          }
+        }
+
+        // Tool calls
+        if (Array.isArray(msg.content)) {
+          for (const block of msg.content) {
+            if (
+              block &&
+              typeof block === 'object' &&
+              'type' in block &&
+              (block as Record<string, unknown>).type === 'tool_use'
+            ) {
+              const toolName = (block as Record<string, unknown>).name as string
+              if (toolName) {
+                toolCalls[toolName] = (toolCalls[toolName] || 0) + 1
+              }
+            }
+          }
+        }
+      }
+    }
+
+    if (userMessages === 0 && assistantMessages === 0) return null
+
+    const durationMinutes =
+      startTime && endTime
+        ? (new Date(endTime).getTime() - new Date(startTime).getTime()) / 60000
+        : 0
+
+    const sessionId = path.basename(filePath, '.jsonl')
+
+    return {
+      sessionId,
+      project: '',
+      projectPath: '',
+      startTime,
+      endTime,
+      durationMinutes: Math.max(0, durationMinutes),
+      userMessages,
+      assistantMessages,
+      totalMessages: userMessages + assistantMessages,
+      inputTokens,
+      outputTokens,
+      cacheCreationTokens,
+      cacheReadTokens,
+      totalTokens: inputTokens + outputTokens + cacheCreationTokens + cacheReadTokens,
+      costUSD,
+      model: model || 'unknown',
+      toolCalls,
+      toolCallsTotal: Object.values(toolCalls).reduce((a, b) => a + b, 0),
+    }
+  } catch {
+    return null
+  }
+}
+
+export async function parseAllLogs(): Promise<UsageData> {
+  const allPricing = await loadPricing()
+
+  if (!fs.existsSync(PROJECTS_DIR)) {
+    return emptyUsageData()
+  }
+
+  const projectDirs = fs.readdirSync(PROJECTS_DIR).filter((d) => {
+    return fs.statSync(path.join(PROJECTS_DIR, d)).isDirectory()
+  })
+
+  const sessions: SessionSummary[] = []
+  const projectMap = new Map<string, ProjectSummary>()
+  const dailyMap = new Map<string, DailyUsage>()
+  const toolUsage: Record<string, number> = {}
+
+  for (const dir of projectDirs) {
+    const projectPath = decodeProjectPath(dir)
+    const projectName = getProjectName(projectPath)
+    const dirPath = path.join(PROJECTS_DIR, dir)
+
+    const jsonlFiles = fs.readdirSync(dirPath).filter((f) => f.endsWith('.jsonl'))
+
+    for (const file of jsonlFiles) {
+      const session = parseSessionFile(path.join(dirPath, file), allPricing)
+      if (!session) continue
+
+      session.project = projectName
+      session.projectPath = projectPath
+      sessions.push(session)
+
+      // Aggregate project stats
+      if (!projectMap.has(projectName)) {
+        projectMap.set(projectName, {
+          name: projectName,
+          path: projectPath,
+          sessions: 0,
+          totalMessages: 0,
+          totalTokens: 0,
+          totalCost: 0,
+          totalDurationMinutes: 0,
+          toolCalls: {},
+        })
+      }
+      const proj = projectMap.get(projectName)!
+      proj.sessions++
+      proj.totalMessages += session.totalMessages
+      proj.totalTokens += session.totalTokens
+      proj.totalCost += session.costUSD
+      proj.totalDurationMinutes += session.durationMinutes
+      for (const [tool, count] of Object.entries(session.toolCalls)) {
+        proj.toolCalls[tool] = (proj.toolCalls[tool] || 0) + count
+      }
+
+      // Aggregate daily stats
+      if (session.startTime) {
+        const date = session.startTime.slice(0, 10)
+        if (!dailyMap.has(date)) {
+          dailyMap.set(date, {
+            date,
+            sessions: 0,
+            messages: 0,
+            inputTokens: 0,
+            outputTokens: 0,
+            cacheCreationTokens: 0,
+            cacheReadTokens: 0,
+            totalTokens: 0,
+            costUSD: 0,
+            toolCalls: 0,
+          })
+        }
+        const daily = dailyMap.get(date)!
+        daily.sessions++
+        daily.messages += session.totalMessages
+        daily.inputTokens += session.inputTokens
+        daily.outputTokens += session.outputTokens
+        daily.cacheCreationTokens += session.cacheCreationTokens
+        daily.cacheReadTokens += session.cacheReadTokens
+        daily.totalTokens += session.totalTokens
+        daily.costUSD += session.costUSD
+        daily.toolCalls += session.toolCallsTotal
+      }
+
+      // Aggregate tool usage
+      for (const [tool, count] of Object.entries(session.toolCalls)) {
+        toolUsage[tool] = (toolUsage[tool] || 0) + count
+      }
+    }
+  }
+
+  // Sort sessions by start time desc
+  sessions.sort((a, b) => (b.startTime || '').localeCompare(a.startTime || ''))
+
+  // Build daily array sorted by date
+  const daily = Array.from(dailyMap.values()).sort((a, b) => a.date.localeCompare(b.date))
+
+  // Build projects array sorted by cost desc
+  const projects = Array.from(projectMap.values()).sort((a, b) => b.totalCost - a.totalCost)
+
+  // Build overview
+  const models: Record<string, number> = {}
+  for (const s of sessions) {
+    models[s.model] = (models[s.model] || 0) + 1
+  }
+
+  const overview: OverviewStats = {
+    totalSessions: sessions.length,
+    totalProjects: projects.length,
+    totalMessages: sessions.reduce((a, s) => a + s.totalMessages, 0),
+    totalUserMessages: sessions.reduce((a, s) => a + s.userMessages, 0),
+    totalAssistantMessages: sessions.reduce((a, s) => a + s.assistantMessages, 0),
+    totalInputTokens: sessions.reduce((a, s) => a + s.inputTokens, 0),
+    totalOutputTokens: sessions.reduce((a, s) => a + s.outputTokens, 0),
+    totalCacheCreationTokens: sessions.reduce((a, s) => a + s.cacheCreationTokens, 0),
+    totalCacheReadTokens: sessions.reduce((a, s) => a + s.cacheReadTokens, 0),
+    totalTokens: sessions.reduce((a, s) => a + s.totalTokens, 0),
+    totalCostUSD: sessions.reduce((a, s) => a + s.costUSD, 0),
+    totalDurationMinutes: sessions.reduce((a, s) => a + s.durationMinutes, 0),
+    totalToolCalls: sessions.reduce((a, s) => a + s.toolCallsTotal, 0),
+    models,
+  }
+
+  return { overview, sessions, projects, daily, toolUsage }
+}
+
+function emptyUsageData(): UsageData {
+  return {
+    overview: {
+      totalSessions: 0,
+      totalProjects: 0,
+      totalMessages: 0,
+      totalUserMessages: 0,
+      totalAssistantMessages: 0,
+      totalInputTokens: 0,
+      totalOutputTokens: 0,
+      totalCacheCreationTokens: 0,
+      totalCacheReadTokens: 0,
+      totalTokens: 0,
+      totalCostUSD: 0,
+      totalDurationMinutes: 0,
+      totalToolCalls: 0,
+      models: {},
+    },
+    sessions: [],
+    projects: [],
+    daily: [],
+    toolUsage: {},
+  }
+}