agentfit 0.1.0

package/lib/pricing.ts

@@ -0,0 +1,112 @@
+// Fetches pricing from LiteLLM's model pricing database (same source as ccusage)
+
+const LITELLM_PRICING_URL =
+  'https://raw.githubusercontent.com/BerriAI/litellm/main/model_prices_and_context_window.json'
+
+export interface ModelPricing {
+  input_cost_per_token?: number
+  output_cost_per_token?: number
+  cache_creation_input_token_cost?: number
+  cache_read_input_token_cost?: number
+}
+
+let pricingCache: Record<string, ModelPricing> | null = null
+
+export async function loadPricing(): Promise<Record<string, ModelPricing>> {
+  if (pricingCache) return pricingCache
+
+  try {
+    const res = await fetch(LITELLM_PRICING_URL, { next: { revalidate: 86400 } })
+    const data = await res.json()
+    // Filter to Claude/Anthropic models only
+    const filtered: Record<string, ModelPricing> = {}
+    for (const [key, value] of Object.entries(data)) {
+      if (
+        key.includes('claude') ||
+        key.includes('anthropic')
+      ) {
+        const v = value as Record<string, unknown>
+        filtered[key] = {
+          input_cost_per_token: v.input_cost_per_token as number | undefined,
+          output_cost_per_token: v.output_cost_per_token as number | undefined,
+          cache_creation_input_token_cost: v.cache_creation_input_token_cost as number | undefined,
+          cache_read_input_token_cost: v.cache_read_input_token_cost as number | undefined,
+        }
+      }
+    }
+    pricingCache = filtered
+    return filtered
+  } catch {
+    // Fallback pricing if fetch fails
+    return getFallbackPricing()
+  }
+}
+
+function getFallbackPricing(): Record<string, ModelPricing> {
+  return {
+    'claude-opus-4-6': {
+      input_cost_per_token: 15e-6,
+      output_cost_per_token: 75e-6,
+      cache_creation_input_token_cost: 18.75e-6,
+      cache_read_input_token_cost: 1.5e-6,
+    },
+    'claude-sonnet-4-6': {
+      input_cost_per_token: 3e-6,
+      output_cost_per_token: 15e-6,
+      cache_creation_input_token_cost: 3.75e-6,
+      cache_read_input_token_cost: 0.3e-6,
+    },
+    'claude-haiku-4-5-20251001': {
+      input_cost_per_token: 0.8e-6,
+      output_cost_per_token: 4e-6,
+      cache_creation_input_token_cost: 1e-6,
+      cache_read_input_token_cost: 0.08e-6,
+    },
+  }
+}
+
+export function findPricing(
+  model: string,
+  allPricing: Record<string, ModelPricing>
+): ModelPricing {
+  // Try exact match
+  if (allPricing[model]) return allPricing[model]
+
+  // Try with anthropic/ prefix
+  if (allPricing[`anthropic/${model}`]) return allPricing[`anthropic/${model}`]
+
+  // Try partial match
+  for (const [key, pricing] of Object.entries(allPricing)) {
+    const normalizedKey = key.replace('anthropic/', '').replace('anthropic.', '')
+    if (normalizedKey === model || normalizedKey.startsWith(model) || model.startsWith(normalizedKey)) {
+      return pricing
+    }
+  }
+
+  // Default to Sonnet pricing
+  return allPricing['claude-sonnet-4-6'] || allPricing['anthropic/claude-sonnet-4-6'] || {
+    input_cost_per_token: 3e-6,
+    output_cost_per_token: 15e-6,
+    cache_creation_input_token_cost: 3.75e-6,
+    cache_read_input_token_cost: 0.3e-6,
+  }
+}
+
+export function calculateCost(
+  model: string,
+  usage: {
+    input_tokens?: number
+    output_tokens?: number
+    cache_creation_input_tokens?: number
+    cache_read_input_tokens?: number
+  },
+  allPricing: Record<string, ModelPricing>
+): number {
+  const pricing = findPricing(model, allPricing)
+  return (
+    (usage.input_tokens || 0) * (pricing.input_cost_per_token || 0) +
+    (usage.output_tokens || 0) * (pricing.output_cost_per_token || 0) +
+    (usage.cache_creation_input_tokens || 0) * (pricing.cache_creation_input_token_cost || 0) +
+    (usage.cache_read_input_tokens || 0) * (pricing.cache_read_input_token_cost || 0)
+  )
+}

package/lib/queries-codex.ts

@@ -0,0 +1,130 @@
+// ─── Codex Usage Data Queries ────────────────────────────────────────
+// Produces UsageData from Codex session logs (no database, parsed live)
+
+import { parseAllCodexSessions } from './parse-codex'
+import type {
+  UsageData,
+  ProjectSummary,
+  DailyUsage,
+  OverviewStats,
+} from './parse-logs'
+
+export function getCodexUsageData(): UsageData {
+  const sessions = parseAllCodexSessions()
+
+  if (sessions.length === 0) {
+    return emptyUsageData()
+  }
+
+  // Aggregate projects
+  const projectMap = new Map<string, ProjectSummary>()
+  const dailyMap = new Map<string, DailyUsage>()
+  const toolUsage: Record<string, number> = {}
+
+  for (const s of sessions) {
+    // Projects
+    if (!projectMap.has(s.project)) {
+      projectMap.set(s.project, {
+        name: s.project,
+        path: s.projectPath,
+        sessions: 0,
+        totalMessages: 0,
+        totalTokens: 0,
+        totalCost: 0,
+        totalDurationMinutes: 0,
+        toolCalls: {},
+      })
+    }
+    const proj = projectMap.get(s.project)!
+    proj.sessions++
+    proj.totalMessages += s.totalMessages
+    proj.totalTokens += s.totalTokens
+    proj.totalCost += s.costUSD
+    proj.totalDurationMinutes += s.durationMinutes
+    for (const [tool, count] of Object.entries(s.toolCalls)) {
+      proj.toolCalls[tool] = (proj.toolCalls[tool] || 0) + count
+    }
+
+    // Daily
+    const date = s.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 += s.totalMessages
+    daily.inputTokens += s.inputTokens
+    daily.outputTokens += s.outputTokens
+    daily.totalTokens += s.totalTokens
+    daily.costUSD += s.costUSD
+    daily.toolCalls += s.toolCallsTotal
+
+    // Tool usage
+    for (const [tool, count] of Object.entries(s.toolCalls)) {
+      toolUsage[tool] = (toolUsage[tool] || 0) + count
+    }
+  }
+
+  const models: Record<string, number> = {}
+  for (const s of sessions) {
+    models[s.model] = (models[s.model] || 0) + 1
+  }
+
+  const projects = Array.from(projectMap.values()).sort((a, b) => b.totalCost - a.totalCost)
+  const daily = Array.from(dailyMap.values()).sort((a, b) => a.date.localeCompare(b.date))
+
+  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: 0,
+    totalCacheReadTokens: 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: {},
+  }
+}

package/lib/queries.ts

@@ -0,0 +1,154 @@
+import { prisma } from './db'
+import type {
+  UsageData,
+  SessionSummary,
+  ProjectSummary,
+  DailyUsage,
+  OverviewStats,
+} from './parse-logs'
+
+export async function getUsageData(): Promise<UsageData> {
+  const dbSessions = await prisma.session.findMany({
+    orderBy: { startTime: 'desc' },
+  })
+
+  if (dbSessions.length === 0) {
+    return emptyUsageData()
+  }
+
+  // Map DB rows to SessionSummary
+  const sessions: SessionSummary[] = dbSessions.map((s) => ({
+    sessionId: s.sessionId,
+    project: s.project,
+    projectPath: s.projectPath,
+    startTime: s.startTime.toISOString(),
+    endTime: s.endTime.toISOString(),
+    durationMinutes: s.durationMinutes,
+    userMessages: s.userMessages,
+    assistantMessages: s.assistantMessages,
+    totalMessages: s.totalMessages,
+    inputTokens: s.inputTokens,
+    outputTokens: s.outputTokens,
+    cacheCreationTokens: s.cacheCreationTokens,
+    cacheReadTokens: s.cacheReadTokens,
+    totalTokens: s.totalTokens,
+    costUSD: s.costUSD,
+    model: s.model,
+    toolCalls: JSON.parse(s.toolCallsJson) as Record<string, number>,
+    toolCallsTotal: s.toolCallsTotal,
+  }))
+
+  // Aggregate projects
+  const projectMap = new Map<string, ProjectSummary>()
+  const dailyMap = new Map<string, DailyUsage>()
+  const toolUsage: Record<string, number> = {}
+
+  for (const s of sessions) {
+    // Projects
+    if (!projectMap.has(s.project)) {
+      projectMap.set(s.project, {
+        name: s.project,
+        path: s.projectPath,
+        sessions: 0,
+        totalMessages: 0,
+        totalTokens: 0,
+        totalCost: 0,
+        totalDurationMinutes: 0,
+        toolCalls: {},
+      })
+    }
+    const proj = projectMap.get(s.project)!
+    proj.sessions++
+    proj.totalMessages += s.totalMessages
+    proj.totalTokens += s.totalTokens
+    proj.totalCost += s.costUSD
+    proj.totalDurationMinutes += s.durationMinutes
+    for (const [tool, count] of Object.entries(s.toolCalls)) {
+      proj.toolCalls[tool] = (proj.toolCalls[tool] || 0) + count
+    }
+
+    // Daily
+    const date = s.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 += s.totalMessages
+    daily.inputTokens += s.inputTokens
+    daily.outputTokens += s.outputTokens
+    daily.cacheCreationTokens += s.cacheCreationTokens
+    daily.cacheReadTokens += s.cacheReadTokens
+    daily.totalTokens += s.totalTokens
+    daily.costUSD += s.costUSD
+    daily.toolCalls += s.toolCallsTotal
+
+    // Tool usage
+    for (const [tool, count] of Object.entries(s.toolCalls)) {
+      toolUsage[tool] = (toolUsage[tool] || 0) + count
+    }
+  }
+
+  const dailyArr = Array.from(dailyMap.values()).sort((a, b) => a.date.localeCompare(b.date))
+  const projects = Array.from(projectMap.values()).sort((a, b) => b.totalCost - a.totalCost)
+
+  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: dailyArr, 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: {},
+  }
+}

package/lib/resolve-icon.ts

@@ -0,0 +1,12 @@
+import * as icons from 'lucide-react'
+import { Puzzle } from 'lucide-react'
+import type { ComponentType } from 'react'
+
+/**
+ * Resolve a lucide-react icon by name string.
+ * Falls back to the Puzzle icon if the name is not found.
+ */
+export function resolveLucideIcon(name: string): ComponentType<{ className?: string }> {
+  const Icon = (icons as unknown as Record<string, ComponentType<{ className?: string }>>)[name]
+  return Icon || Puzzle
+}