@dropalltables/yacu 0.1.0

package/src/data/sources/gemini.ts

@@ -0,0 +1,112 @@
+import { homedir } from "node:os"
+import { basename, join } from "node:path"
+import { localDate } from "../../domain/dates"
+import type { UsageRecord, UsageSession } from "../../domain/types"
+import { estimateCacheSavings, estimateCost } from "../pricing"
+import { asObject, globFiles, numberValue, stringValue } from "../jsonl"
+import type { SourceLoadResult } from "../types"
+
+type ParsedConversation = {
+  sessionId: string
+  startTime: string | null
+  messages: Array<Record<string, unknown>>
+}
+
+export async function loadGeminiUsage(): Promise<SourceLoadResult> {
+  const root = process.env.GEMINI_HOME ?? join(homedir(), ".gemini")
+  const files = [
+    ...await globFiles(join(root, "tmp"), "**/chats/*.json"),
+    ...await globFiles(join(root, "tmp"), "**/chats/*.jsonl"),
+  ]
+  const records: UsageRecord[] = []
+  const sessions = new Map<string, UsageSession>()
+
+  for (const path of files) {
+    let parsed: ParsedConversation | null = null
+    try {
+      parsed = parseGeminiConversation(await Bun.file(path).text(), basename(path))
+    } catch {
+      continue
+    }
+    if (parsed == null) continue
+    const sessionId = `gemini:${parsed.sessionId}`
+
+    for (const message of parsed.messages) {
+      if (message.type !== "gemini") continue
+      const usage = asObject(message.tokens) ?? asObject(message.usageMetadata)
+      if (usage == null) continue
+      const cached = numberValue(usage.cached) || numberValue(usage.cachedContentTokenCount)
+      const prompt = numberValue(usage.input) || numberValue(usage.promptTokenCount)
+      const candidates = numberValue(usage.output) || numberValue(usage.candidatesTokenCount)
+      const thoughts = numberValue(usage.thoughts) || numberValue(usage.thoughtsTokenCount)
+      const tool = numberValue(usage.tool) || numberValue(usage.toolUsePromptTokenCount)
+      const tokens = {
+        inputTokens: Math.max(0, prompt - cached) + tool,
+        outputTokens: candidates + thoughts,
+        cacheCreationTokens: 0,
+        cacheReadTokens: cached,
+      }
+      if (Object.values(tokens).every((value) => value === 0)) continue
+      const model = stringValue(message.model) ?? "gemini"
+      const timestamp = stringValue(message.timestamp) ?? parsed.startTime ?? new Date().toISOString()
+      const date = localDate(timestamp)
+      records.push({
+        date,
+        source: "gemini",
+        model,
+        sessionId,
+        ...tokens,
+        costUsd: estimateCost(model, tokens),
+        cacheSavingsUsd: estimateCacheSavings(model, cached),
+      })
+      sessions.set(sessionId, { id: sessionId, source: "gemini", date })
+    }
+  }
+
+  return { records, sessions: [...sessions.values()], files: files.length }
+}
+
+export function parseGeminiConversation(text: string, fallbackId = "session"): ParsedConversation | null {
+  const trimmed = text.trim()
+  if (trimmed === "") return null
+
+  try {
+    const full = asObject(JSON.parse(trimmed))
+    if (full != null && Array.isArray(full.messages)) {
+      return {
+        sessionId: stringValue(full.sessionId) ?? fallbackId,
+        startTime: stringValue(full.startTime),
+        messages: full.messages.flatMap((message) => {
+          const row = asObject(message)
+          return row == null ? [] : [row]
+        }),
+      }
+    }
+  } catch {
+    // JSONL is parsed below.
+  }
+
+  let sessionId = fallbackId
+  let startTime: string | null = null
+  const messages: Array<Record<string, unknown>> = []
+  for (const line of trimmed.split("\n")) {
+    let row: Record<string, unknown> | null = null
+    try {
+      row = asObject(JSON.parse(line))
+    } catch {
+      continue
+    }
+    if (row == null) continue
+    const metadata = asObject(row.$set) ?? row
+    sessionId = stringValue(metadata.sessionId) ?? sessionId
+    startTime = stringValue(metadata.startTime) ?? startTime
+    const rewindTo = stringValue(row.$rewindTo)
+    if (rewindTo != null) {
+      const index = messages.findIndex((message) => message.id === rewindTo)
+      if (index >= 0) messages.splice(index + 1)
+    } else if (stringValue(row.type) != null) {
+      messages.push(row)
+    }
+  }
+  return { sessionId, startTime, messages }
+}

package/src/data/sources/grok.ts

@@ -0,0 +1,60 @@
+import { homedir } from "node:os"
+import { basename, dirname, join } from "node:path"
+import { localDate } from "../../domain/dates"
+import type { UsageRecord, UsageSession } from "../../domain/types"
+import { estimateCacheSavings, estimateCost } from "../pricing"
+import { asObject, forEachJsonLine, globFiles, numberValue, stringValue } from "../jsonl"
+import type { SourceLoadResult } from "../types"
+
+export async function loadGrokUsage(): Promise<SourceLoadResult> {
+  const root = process.env.GROK_HOME ?? join(homedir(), ".grok")
+  const files = await globFiles(join(root, "sessions"), "**/updates.jsonl")
+  const records: UsageRecord[] = []
+  const sessions = new Map<string, UsageSession>()
+
+  for (const path of files) {
+    const sessionId = `grok:${basename(dirname(path))}`
+    await forEachJsonLine(path, (unknownValue) => {
+      const value = asObject(unknownValue)
+      const update = asObject(value?.update)
+      const usage = asObject(update?.usage)
+      if (update?.sessionUpdate !== "turn_completed" || usage == null) return
+      const metadata = asObject(value?._meta)
+      const timestamp = stringValue(value?.timestamp) ?? (numberValue(metadata?.agentTimestampMs) || Date.now())
+      const date = localDate(timestamp)
+      const models = asObject(usage.modelUsage)
+      const entries = models == null ? [["grok-build", usage] as const] : Object.entries(models)
+      const cost = numberValue(usage.costUsdTicks) / 1_000_000_000
+      const tokenWeights = entries.map(([, entry]) => {
+        const tokens = asObject(entry)
+        return numberValue(tokens?.inputTokens) + numberValue(tokens?.outputTokens)
+      })
+      const totalWeight = tokenWeights.reduce((sum, value) => sum + value, 0)
+
+      entries.forEach(([model, entry], index) => {
+        const raw = asObject(entry)
+        const cached = numberValue(raw?.cachedReadTokens)
+        const input = Math.max(0, numberValue(raw?.inputTokens) - cached)
+        const tokens = {
+          inputTokens: input,
+          outputTokens: numberValue(raw?.outputTokens),
+          cacheCreationTokens: 0,
+          cacheReadTokens: cached,
+        }
+        const allocatedCost = totalWeight > 0 ? cost * (tokenWeights[index]! / totalWeight) : 0
+        records.push({
+          date,
+          source: "grok",
+          model,
+          sessionId,
+          ...tokens,
+          costUsd: allocatedCost || estimateCost(model, tokens),
+          cacheSavingsUsd: estimateCacheSavings(model, cached),
+        })
+      })
+      sessions.set(sessionId, { id: sessionId, source: "grok", date })
+    })
+  }
+
+  return { records, sessions: [...sessions.values()], files: files.length }
+}

package/src/data/sources/opencode.ts

@@ -0,0 +1,53 @@
+import { homedir } from "node:os"
+import { join } from "node:path"
+import { localDate } from "../../domain/dates"
+import type { UsageRecord, UsageSession } from "../../domain/types"
+import { estimateCacheSavings, estimateCost } from "../pricing"
+import { asObject, globFiles, numberValue, stringValue } from "../jsonl"
+import type { SourceLoadResult } from "../types"
+
+export async function loadOpenCodeUsage(): Promise<SourceLoadResult> {
+  const root = process.env.OPENCODE_DATA_DIR ?? join(homedir(), ".local", "share", "opencode")
+  const files = await globFiles(join(root, "storage", "message"), "**/*.json")
+  const seen = new Set<string>()
+  const records: UsageRecord[] = []
+  const sessions = new Map<string, UsageSession>()
+
+  for (const path of files) {
+    try {
+      const message = asObject(await Bun.file(path).json())
+      const id = stringValue(message?.id)
+      const model = stringValue(message?.modelID)
+      const tokensValue = asObject(message?.tokens)
+      if (id == null || model == null || tokensValue == null || seen.has(id)) continue
+      seen.add(id)
+      const cache = asObject(tokensValue.cache)
+      const tokens = {
+        inputTokens: numberValue(tokensValue.input),
+        outputTokens: numberValue(tokensValue.output),
+        cacheCreationTokens: numberValue(cache?.write),
+        cacheReadTokens: numberValue(cache?.read),
+      }
+      if (Object.values(tokens).every((value) => value === 0)) continue
+      const time = asObject(message?.time)
+      const date = localDate(numberValue(time?.created) || Date.now())
+      const rawSession = stringValue(message?.sessionID) ?? id
+      const sessionId = `opencode:${rawSession}`
+      const localCost = typeof message?.cost === "number" ? message.cost : null
+      records.push({
+        date,
+        source: "opencode",
+        model,
+        sessionId,
+        ...tokens,
+        costUsd: localCost ?? estimateCost(model, tokens),
+        cacheSavingsUsd: estimateCacheSavings(model, tokens.cacheReadTokens),
+      })
+      sessions.set(sessionId, { id: sessionId, source: "opencode", date })
+    } catch {
+      continue
+    }
+  }
+
+  return { records, sessions: [...sessions.values()], files: files.length }
+}

package/src/data/types.ts

@@ -0,0 +1,23 @@
+import type { SourceId, UsageRecord, UsageSession } from "../domain/types"
+
+export type SourceLoadResult = {
+  records: UsageRecord[]
+  sessions: UsageSession[]
+  files: number
+}
+
+export type ScanStatus = "pending" | "scanning" | "done" | "error"
+
+export type ScanProgress = {
+  source: SourceId
+  label: string
+  status: ScanStatus
+  completed: number
+  total: number
+  files?: number
+  records?: number
+  sessions?: number
+  error?: string
+}
+
+export type ScanProgressHandler = (progress: ScanProgress) => void

package/src/domain/aggregate.test.ts

@@ -0,0 +1,62 @@
+import { describe, expect, test } from "bun:test"
+import { localDate } from "./dates"
+import { buildDashboard } from "./aggregate"
+import type { UsageDataset } from "./types"
+
+const today = localDate(new Date())
+const dataset: UsageDataset = {
+  scannedAt: new Date(),
+  errors: [],
+  sessions: [
+    { id: "claude-1", source: "claude", date: today },
+    { id: "codex-1", source: "codex", date: today },
+  ],
+  records: [
+    {
+      date: today,
+      source: "claude",
+      model: "claude-opus-4-1",
+      sessionId: "claude-1",
+      inputTokens: 100,
+      outputTokens: 20,
+      cacheCreationTokens: 10,
+      cacheReadTokens: 70,
+      costUsd: 2,
+      cacheSavingsUsd: 0.1,
+    },
+    {
+      date: today,
+      source: "codex",
+      model: "gpt-5-codex",
+      sessionId: "codex-1",
+      inputTokens: 50,
+      outputTokens: 25,
+      cacheCreationTokens: 0,
+      cacheReadTokens: 25,
+      costUsd: 1,
+      cacheSavingsUsd: 0.05,
+    },
+  ],
+}
+
+describe("buildDashboard", () => {
+  test("aggregates providers, sessions, and models", () => {
+    const dashboard = buildDashboard(dataset, 1, "cost")
+
+    expect(dashboard.totals.processedTokens).toBe(300)
+    expect(dashboard.totals.costUsd).toBe(3)
+    expect(dashboard.sessions).toBe(2)
+    expect(dashboard.providers.map((provider) => provider.source)).toEqual(["codex", "claude"])
+    expect(dashboard.providers[0]?.share).toBeCloseTo(1 / 3)
+    expect(dashboard.models[0]?.label).toBe("claude-opus-4-1")
+  })
+
+  test("uses token share when token mode is selected", () => {
+    const dashboard = buildDashboard(dataset, 1, "tokens")
+
+    expect(dashboard.providers[0]?.share).toBeCloseTo(1 / 3)
+    expect(dashboard.providers[1]?.share).toBeCloseTo(2 / 3)
+    expect(dashboard.series.claude.at(-1)).toBe(200)
+    expect(dashboard.series.codex.at(-1)).toBe(100)
+  })
+})

package/src/domain/aggregate.ts

@@ -0,0 +1,143 @@
+import { datesInRange } from "./dates"
+import {
+  SOURCE_ORDER,
+  type Metric,
+  type RangeDays,
+  type SourceId,
+  type UsageDataset,
+  type UsageRecord,
+} from "./types"
+
+type Totals = {
+  inputTokens: number
+  outputTokens: number
+  cacheCreationTokens: number
+  cacheReadTokens: number
+  processedTokens: number
+  costUsd: number
+  cacheSavingsUsd: number
+}
+
+export type ProviderStat = Totals & {
+  source: SourceId
+  sessions: number
+  share: number
+}
+
+export type BreakdownRow = Totals & {
+  key: string
+  label: string
+  source?: SourceId
+  share: number
+}
+
+export type Dashboard = {
+  days: string[]
+  records: UsageRecord[]
+  totals: Totals
+  sessions: number
+  providers: ProviderStat[]
+  models: BreakdownRow[]
+  daily: BreakdownRow[]
+  series: Record<SourceId, number[]>
+}
+
+function emptyTotals(): Totals {
+  return {
+    inputTokens: 0,
+    outputTokens: 0,
+    cacheCreationTokens: 0,
+    cacheReadTokens: 0,
+    processedTokens: 0,
+    costUsd: 0,
+    cacheSavingsUsd: 0,
+  }
+}
+
+function addRecord(target: Totals, record: UsageRecord): void {
+  target.inputTokens += record.inputTokens
+  target.outputTokens += record.outputTokens
+  target.cacheCreationTokens += record.cacheCreationTokens
+  target.cacheReadTokens += record.cacheReadTokens
+  target.processedTokens +=
+    record.inputTokens + record.outputTokens + record.cacheCreationTokens + record.cacheReadTokens
+  target.costUsd += record.costUsd
+  target.cacheSavingsUsd += record.cacheSavingsUsd
+}
+
+function metricValue(totals: Totals, metric: Metric): number {
+  return metric === "cost" ? totals.costUsd : totals.processedTokens
+}
+
+export function buildDashboard(dataset: UsageDataset, range: RangeDays, metric: Metric): Dashboard {
+  const days = datesInRange(range)
+  const dateSet = new Set(days)
+  const records = dataset.records.filter((record) => dateSet.has(record.date))
+  const sessions = dataset.sessions.filter((session) => dateSet.has(session.date))
+  const totals = emptyTotals()
+  for (const record of records) addRecord(totals, record)
+
+  const providerMap = new Map<SourceId, Totals>()
+  const providerSessions = new Map<SourceId, Set<string>>()
+  for (const record of records) {
+    const aggregate = providerMap.get(record.source) ?? emptyTotals()
+    addRecord(aggregate, record)
+    providerMap.set(record.source, aggregate)
+  }
+  for (const session of sessions) {
+    const ids = providerSessions.get(session.source) ?? new Set<string>()
+    ids.add(session.id)
+    providerSessions.set(session.source, ids)
+  }
+  const metricTotal = metricValue(totals, metric)
+  const providers = SOURCE_ORDER.filter((source) => providerMap.has(source)).map((source) => {
+    const values = providerMap.get(source) ?? emptyTotals()
+    return {
+      ...values,
+      source,
+      sessions: providerSessions.get(source)?.size ?? 0,
+      share: metricTotal > 0 ? metricValue(values, metric) / metricTotal : 0,
+    }
+  })
+
+  const modelMap = new Map<string, BreakdownRow>()
+  for (const record of records) {
+    const key = `${record.source}\0${record.model}`
+    const row = modelMap.get(key) ?? {
+      ...emptyTotals(),
+      key,
+      label: record.model,
+      source: record.source,
+      share: 0,
+    }
+    addRecord(row, record)
+    modelMap.set(key, row)
+  }
+  const models = [...modelMap.values()]
+    .map((row) => ({ ...row, share: metricTotal > 0 ? metricValue(row, metric) / metricTotal : 0 }))
+    .sort((a, b) => metricValue(b, metric) - metricValue(a, metric))
+
+  const dailyMap = new Map<string, BreakdownRow>()
+  for (const day of days) {
+    dailyMap.set(day, { ...emptyTotals(), key: day, label: day, share: 0 })
+  }
+  for (const record of records) addRecord(dailyMap.get(record.date)!, record)
+  const daily = [...dailyMap.values()]
+    .map((row) => ({ ...row, share: metricTotal > 0 ? metricValue(row, metric) / metricTotal : 0 }))
+    .sort((a, b) => metricValue(b, metric) - metricValue(a, metric))
+
+  const series = Object.fromEntries(
+    SOURCE_ORDER.map((source) => {
+      const values = days.map((day) => {
+        const dayTotals = emptyTotals()
+        for (const record of records) {
+          if (record.source === source && record.date === day) addRecord(dayTotals, record)
+        }
+        return metricValue(dayTotals, metric)
+      })
+      return [source, values]
+    }),
+  ) as Record<SourceId, number[]>
+
+  return { days, records, totals, sessions: new Set(sessions.map((session) => session.id)).size, providers, models, daily, series }
+}

package/src/domain/dates.ts

@@ -0,0 +1,24 @@
+export function localDate(value: string | number | Date): string {
+  const date = value instanceof Date ? value : new Date(value)
+  const year = date.getFullYear()
+  const month = String(date.getMonth() + 1).padStart(2, "0")
+  const day = String(date.getDate()).padStart(2, "0")
+  return `${year}-${month}-${day}`
+}
+
+export function dateDaysAgo(daysAgo: number): string {
+  const date = new Date()
+  date.setHours(0, 0, 0, 0)
+  date.setDate(date.getDate() - daysAgo)
+  return localDate(date)
+}
+
+export function datesInRange(days: number): string[] {
+  return Array.from({ length: days }, (_, index) => dateDaysAgo(days - index - 1))
+}
+
+export function shortDate(value: string): string {
+  return new Intl.DateTimeFormat("en-US", { month: "short", day: "numeric" }).format(
+    new Date(`${value}T12:00:00`),
+  )
+}

package/src/domain/types.ts

@@ -0,0 +1,48 @@
+export type SourceId = "claude" | "codex" | "cursor" | "gemini" | "opencode" | "grok"
+
+export type UsageRecord = {
+  date: string
+  source: SourceId
+  model: string
+  sessionId?: string
+  inputTokens: number
+  outputTokens: number
+  cacheCreationTokens: number
+  cacheReadTokens: number
+  costUsd: number
+  cacheSavingsUsd: number
+}
+
+export type UsageSession = {
+  id: string
+  source: SourceId
+  date: string
+}
+
+export type UsageDataset = {
+  records: UsageRecord[]
+  sessions: UsageSession[]
+  errors: string[]
+  scannedAt: Date
+}
+
+export type Metric = "cost" | "tokens"
+export type RangeDays = 1 | 7 | 30 | 90
+export type BreakdownMode = "model" | "day"
+
+export type SourceMeta = {
+  id: SourceId
+  label: string
+  mark: string
+}
+
+export const SOURCE_META: Record<SourceId, SourceMeta> = {
+  claude: { id: "claude", label: "Claude Code", mark: "*" },
+  codex: { id: "codex", label: "Codex", mark: "o" },
+  cursor: { id: "cursor", label: "Cursor", mark: ">" },
+  gemini: { id: "gemini", label: "Gemini CLI", mark: "g" },
+  grok: { id: "grok", label: "Grok Build", mark: "x" },
+  opencode: { id: "opencode", label: "OpenCode", mark: "+" },
+}
+
+export const SOURCE_ORDER: SourceId[] = ["codex", "claude", "cursor", "gemini", "grok", "opencode"]

package/src/index.tsx

@@ -0,0 +1,15 @@
+#!/usr/bin/env bun
+import { createCliRenderer, RGBA } from "@opentui/core"
+import { createRoot } from "@opentui/react"
+import { App } from "./tui/App"
+
+const renderer = await createCliRenderer({
+  backgroundColor: RGBA.defaultBackground("#1e1e1e"),
+  exitOnCtrlC: true,
+  targetFps: 30,
+  useMouse: true,
+  enableMouseMovement: true,
+  autoFocus: false,
+})
+
+createRoot(renderer).render(<App />)