agentfit 0.1.8 → 0.1.10

package/components/data-provider.tsx

@@ -3,6 +3,7 @@
 import { createContext, useContext, useEffect, useState, useCallback, useMemo, type ReactNode } from 'react'
 import { toast } from 'sonner'
 import type { UsageData, SessionSummary, DailyUsage, ProjectSummary, OverviewStats } from '@/lib/parse-logs'
+import { formatLocalDate } from '@/lib/format'
 
 export type AgentType = 'claude' | 'codex' | 'combined'
 export type TimeRange = '7d' | '30d' | '90d' | 'all'
@@ -58,6 +59,7 @@ function filterData(raw: UsageData | null, range: TimeRange, project: string): U
   const cutoff = new Date()
   cutoff.setDate(cutoff.getDate() - days)
   const cutoffISO = range === 'all' ? '' : cutoff.toISOString()
+  const cutoffDate = range === 'all' ? '' : formatLocalDate(cutoff)
 
   // Filter sessions by time range and project
   const sessions = raw.sessions.filter(s => {
@@ -66,14 +68,57 @@ function filterData(raw: UsageData | null, range: TimeRange, project: string): U
     return true
   })
 
-  // Re-aggregate from filtered sessions
+  // Daily: preserve the server's per-message-derived rows (with
+  // modelBreakdowns intact, including haiku/sub-agent tokens) when the
+  // project filter is inactive — only trim by date. Re-aggregating from
+  // session rollups loses the per-(date, model) split, mis-buckets
+  // cross-midnight tokens, and can drift from ccusage. When a project
+  // filter IS active we have no choice but to rebuild from sessions, since
+  // per-message rows aren't tagged by project on the client.
+  let daily: DailyUsage[]
+  if (project === 'all') {
+    daily = raw.daily.filter(d => range === 'all' || d.date >= cutoffDate)
+  } else {
+    const dailyMap = new Map<string, DailyUsage>()
+    for (const s of sessions) {
+      const date = formatLocalDate(new Date(s.startTime))
+      if (!dailyMap.has(date)) {
+        dailyMap.set(date, {
+          date, sessions: 0, messages: 0,
+          userMessages: 0, assistantMessages: 0,
+          inputTokens: 0, outputTokens: 0,
+          cacheCreationTokens: 0, cacheReadTokens: 0,
+          totalTokens: 0, costUSD: 0, toolCalls: 0,
+          toolCallsDetail: {}, interruptions: 0, rateLimitErrors: 0,
+          modelBreakdowns: [],
+        })
+      }
+      const day = dailyMap.get(date)!
+      day.sessions++
+      day.messages += s.totalMessages
+      day.userMessages += s.userMessages
+      day.assistantMessages += s.assistantMessages
+      day.inputTokens += s.inputTokens
+      day.outputTokens += s.outputTokens
+      day.cacheCreationTokens += s.cacheCreationTokens
+      day.cacheReadTokens += s.cacheReadTokens
+      day.totalTokens += s.totalTokens
+      day.costUSD += s.costUSD
+      day.toolCalls += s.toolCallsTotal
+      day.interruptions += s.userInterruptions
+      day.rateLimitErrors += s.rateLimitErrors
+      for (const [tool, count] of Object.entries(s.toolCalls)) {
+        day.toolCallsDetail[tool] = (day.toolCallsDetail[tool] || 0) + count
+      }
+    }
+    daily = Array.from(dailyMap.values()).sort((a, b) => a.date.localeCompare(b.date))
+  }
+
   const projectMap = new Map<string, ProjectSummary>()
-  const dailyMap = new Map<string, DailyUsage>()
   const toolUsage: Record<string, number> = {}
   const models: Record<string, number> = {}
 
   for (const s of sessions) {
-    // Projects
     if (!projectMap.has(s.project)) {
       projectMap.set(s.project, {
         name: s.project,
@@ -94,55 +139,27 @@ function filterData(raw: UsageData | null, range: TimeRange, project: string): U
     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,
-        userMessages: 0, assistantMessages: 0,
-        inputTokens: 0, outputTokens: 0,
-        cacheCreationTokens: 0, cacheReadTokens: 0,
-        totalTokens: 0, costUSD: 0, toolCalls: 0,
-        toolCallsDetail: {}, interruptions: 0, rateLimitErrors: 0,
-        // Client-side rebuild: per-(date, model) breakdown is not derivable
-        // from session-level rows. The unfiltered case (project=all,
-        // range=all) returns raw and preserves the server's breakdowns.
-        modelBreakdowns: [],
-      })
-    }
-    const day = dailyMap.get(date)!
-    day.sessions++
-    day.messages += s.totalMessages
-    day.userMessages += s.userMessages
-    day.assistantMessages += s.assistantMessages
-    day.inputTokens += s.inputTokens
-    day.outputTokens += s.outputTokens
-    day.cacheCreationTokens += s.cacheCreationTokens
-    day.cacheReadTokens += s.cacheReadTokens
-    day.totalTokens += s.totalTokens
-    day.costUSD += s.costUSD
-    day.toolCalls += s.toolCallsTotal
-    day.interruptions += s.userInterruptions
-    day.rateLimitErrors += s.rateLimitErrors
-    for (const [tool, count] of Object.entries(s.toolCalls)) {
-      day.toolCallsDetail[tool] = (day.toolCallsDetail[tool] || 0) + count
-    }
-
-    // Tools
-    for (const [tool, count] of Object.entries(s.toolCalls)) {
       toolUsage[tool] = (toolUsage[tool] || 0) + count
     }
-
-    // Models — aggregate at message level
     for (const [m, count] of Object.entries(s.modelCounts || {})) {
       models[m] = (models[m] || 0) + count
     }
   }
 
   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))
+
+  // Overview token/cost totals come from the daily rows so the overview
+  // and the daily breakdown agree (mirrors getUsageData on the server).
+  const tokenTotals = daily.reduce(
+    (acc, d) => ({
+      input: acc.input + d.inputTokens,
+      output: acc.output + d.outputTokens,
+      cc: acc.cc + d.cacheCreationTokens,
+      cr: acc.cr + d.cacheReadTokens,
+      cost: acc.cost + d.costUSD,
+    }),
+    { input: 0, output: 0, cc: 0, cr: 0, cost: 0 }
+  )
 
   const overview: OverviewStats = {
     totalSessions: sessions.length,
@@ -150,22 +167,22 @@ function filterData(raw: UsageData | null, range: TimeRange, project: string): U
     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),
+    totalInputTokens: tokenTotals.input,
+    totalOutputTokens: tokenTotals.output,
+    totalCacheCreationTokens: tokenTotals.cc,
+    totalCacheReadTokens: tokenTotals.cr,
+    totalTokens: tokenTotals.input + tokenTotals.output + tokenTotals.cc + tokenTotals.cr,
+    totalCostUSD: tokenTotals.cost,
     totalSystemPromptEdits: sessions.reduce((a, s) => a + (s.systemPromptEdits ?? 0), 0),
     totalDurationMinutes: sessions.reduce((a, s) => a + s.durationMinutes, 0),
     totalToolCalls: sessions.reduce((a, s) => a + s.toolCallsTotal, 0),
     totalApiErrors: sessions.reduce((a, s) => a + s.apiErrors, 0),
     totalRateLimitDays: (() => {
-      const days = new Set<string>()
+      const rateDays = new Set<string>()
       for (const s of sessions) {
-        if (s.rateLimitErrors > 0) days.add(s.startTime.slice(0, 10))
+        if (s.rateLimitErrors > 0) rateDays.add(formatLocalDate(new Date(s.startTime)))
       }
-      return days.size
+      return rateDays.size
     })(),
     totalUserInterruptions: sessions.reduce((a, s) => a + s.userInterruptions, 0),
     models,

package/lib/format.ts

@@ -24,3 +24,15 @@ export function formatDuration(minutes: number): string {
 export function formatNumber(n: number): string {
   return n.toLocaleString()
 }
+
+// Local-timezone YYYY-MM-DD bucket. Matches ccusage's _date-utils.ts so daily
+// totals agree to the cent — UTC slicing shifts cross-midnight tokens.
+const LOCAL_DATE_FORMATTER = new Intl.DateTimeFormat('en-CA', {
+  year: 'numeric',
+  month: '2-digit',
+  day: '2-digit',
+})
+
+export function formatLocalDate(d: Date): string {
+  return LOCAL_DATE_FORMATTER.format(d)
+}

package/lib/pricing.ts

@@ -28,7 +28,10 @@ export async function loadPricing(): Promise<Record<string, ModelPricing>> {
   if (pricingCache) return pricingCache
 
   try {
-    const res = await fetch(LITELLM_PRICING_URL, { next: { revalidate: 86400 } })
+    // Bypass Next's data cache; we memoize the parsed result in
+    // `pricingCache` ourselves. Double-caching once let an empty body
+    // freeze every newly-listed model at cost=0 until process restart.
+    const res = await fetch(LITELLM_PRICING_URL, { cache: 'no-store' })
     const data = await res.json()
     const filtered: Record<string, ModelPricing> = {}
     for (const [key, value] of Object.entries(data)) {
@@ -55,6 +58,9 @@ export async function loadPricing(): Promise<Record<string, ModelPricing>> {
             : undefined,
       }
     }
+    // Refuse to memoize an empty map — that would be a transient fetch
+    // hiccup turning into a process-lifetime zero-cost lock.
+    if (Object.keys(filtered).length === 0) return getFallbackPricing()
     pricingCache = filtered
     return filtered
   } catch {

package/lib/sync.ts

@@ -3,19 +3,11 @@ import path from 'path'
 import os from 'os'
 import { prisma } from './db'
 import { loadPricing, calculateCost, type ModelPricing, type Speed } from './pricing'
+import { formatLocalDate } from './format'
 
 const PROJECTS_DIR = path.join(os.homedir(), '.claude', 'projects')
 const IMAGES_DIR = path.resolve(process.cwd(), 'data', 'images')
 
-// Bucket per-message timestamps using the user's *local* timezone so daily
-// totals match ccusage (apps/ccusage/src/_date-utils.ts:43-48). en-CA yields
-// YYYY-MM-DD without zero-padding surprises.
-const DATE_FORMATTER = new Intl.DateTimeFormat('en-CA', {
-  year: 'numeric',
-  month: '2-digit',
-  day: '2-digit',
-})
-
 interface LogEntry {
   type?: string
   uuid?: string
@@ -242,7 +234,7 @@ function parseSessionFile(
             model: currentModel,
             speed,
             timestamp: ts,
-            date: DATE_FORMATTER.format(ts),
+            date: formatLocalDate(ts),
             inputTokens: inT,
             outputTokens: outT,
             cacheCreationTokens: ccT,
@@ -417,7 +409,7 @@ export async function syncLogs(): Promise<SyncResult> {
         if (isSubagent) {
           for (const m of parsed.messageUsages) {
             await prisma.$executeRaw`
-              INSERT OR IGNORE INTO "MessageUsage" (
+              INSERT INTO "MessageUsage" (
                 "id", "sessionId", "messageId", "requestId", "model", "speed",
                 "timestamp", "date",
                 "inputTokens", "outputTokens", "cacheCreationTokens", "cacheReadTokens",
@@ -429,6 +421,8 @@ export async function syncLogs(): Promise<SyncResult> {
                 ${m.inputTokens}, ${m.outputTokens}, ${m.cacheCreationTokens}, ${m.cacheReadTokens},
                 ${m.costUSD}, ${new Date().toISOString()}
               )
+              ON CONFLICT("messageId", "requestId") DO UPDATE SET
+                "costUSD" = MAX("MessageUsage"."costUSD", excluded."costUSD")
             `
           }
           result.sessionsAdded++

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentfit",
-  "version": "0.1.8",
+  "version": "0.1.10",
   "description": "Fitness tracker dashboard for AI coding agents (Claude Code, Codex). Visualize usage, cost, tokens, and productivity from local conversation logs.",
   "type": "module",
   "bin": {