bonecode 1.1.0 → 1.2.0

package/src/stats.ts

@@ -0,0 +1,290 @@
+/**
+ * Token usage and cost statistics
+ * Ported from opencode's cli/cmd/stats.ts — adapted for BoneCode's Postgres schema.
+ */
+
+import { Pool } from "pg"
+
+export interface SessionStats {
+  totalSessions: number
+  totalMessages: number
+  totalCost: number
+  totalTokens: {
+    input: number
+    output: number
+    reasoning: number
+    cache: { read: number; write: number }
+  }
+  toolUsage: Record<string, number>
+  modelUsage: Record<string, {
+    messages: number
+    tokens: { input: number; output: number; cache: { read: number; write: number } }
+    cost: number
+  }>
+  dateRange: { earliest: number; latest: number }
+  days: number
+  costPerDay: number
+  tokensPerSession: number
+  medianTokensPerSession: number
+}
+
+export async function aggregateStats(
+  pool: Pool,
+  opts: { days?: number; projectFilter?: string } = {}
+): Promise<SessionStats> {
+  const MS_IN_DAY = 24 * 60 * 60 * 1000
+
+  const cutoffTime = (() => {
+    if (opts.days === undefined) return 0
+    if (opts.days === 0) {
+      const now = new Date()
+      now.setHours(0, 0, 0, 0)
+      return now.getTime()
+    }
+    return Date.now() - opts.days * MS_IN_DAY
+  })()
+
+  const windowDays = (() => {
+    if (opts.days === undefined) return undefined
+    if (opts.days === 0) return 1
+    return opts.days
+  })()
+
+  // Load sessions
+  let sessionQuery = `SELECT id, project_id, cost_usd, tokens_input, tokens_output, tokens_reasoning,
+    tokens_cache_read, tokens_cache_write, created_at, updated_at
+    FROM sessions WHERE state != 'deleted'`
+  const params: unknown[] = []
+  let idx = 1
+
+  if (cutoffTime > 0) {
+    sessionQuery += ` AND updated_at >= $${idx++}`
+    params.push(new Date(cutoffTime))
+  }
+  if (opts.projectFilter) {
+    sessionQuery += ` AND project_id = $${idx++}`
+    params.push(opts.projectFilter)
+  }
+
+  const sessionsResult = await pool.query(sessionQuery, params)
+  const sessions = sessionsResult.rows
+
+  const stats: SessionStats = {
+    totalSessions: sessions.length,
+    totalMessages: 0,
+    totalCost: 0,
+    totalTokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
+    toolUsage: {},
+    modelUsage: {},
+    dateRange: { earliest: Date.now(), latest: 0 },
+    days: 0,
+    costPerDay: 0,
+    tokensPerSession: 0,
+    medianTokensPerSession: 0,
+  }
+
+  if (sessions.length === 0) {
+    stats.days = windowDays ?? 0
+    return stats
+  }
+
+  let earliestTime = Date.now()
+  let latestTime = 0
+  const sessionTotalTokens: number[] = []
+
+  for (const session of sessions) {
+    const sessionCost = parseFloat(session.cost_usd) || 0
+    const sessionTokens = {
+      input: parseInt(session.tokens_input) || 0,
+      output: parseInt(session.tokens_output) || 0,
+      reasoning: parseInt(session.tokens_reasoning) || 0,
+      cache: {
+        read: parseInt(session.tokens_cache_read) || 0,
+        write: parseInt(session.tokens_cache_write) || 0,
+      },
+    }
+
+    const createdMs = new Date(session.created_at).getTime()
+    const updatedMs = new Date(session.updated_at).getTime()
+    earliestTime = Math.min(earliestTime, cutoffTime > 0 ? updatedMs : createdMs)
+    latestTime = Math.max(latestTime, updatedMs)
+
+    const total = sessionTokens.input + sessionTokens.output + sessionTokens.reasoning +
+      sessionTokens.cache.read + sessionTokens.cache.write
+    sessionTotalTokens.push(total)
+
+    stats.totalCost += sessionCost
+    stats.totalTokens.input += sessionTokens.input
+    stats.totalTokens.output += sessionTokens.output
+    stats.totalTokens.reasoning += sessionTokens.reasoning
+    stats.totalTokens.cache.read += sessionTokens.cache.read
+    stats.totalTokens.cache.write += sessionTokens.cache.write
+
+    // Load messages for this session
+    const msgResult = await pool.query(
+      `SELECT m.id, m.role, m.model_id, m.provider_id, m.cost_usd,
+              m.tokens_input, m.tokens_output,
+              json_agg(p.part_type ORDER BY p.order_index) FILTER (WHERE p.id IS NOT NULL) as part_types
+       FROM messages m
+       LEFT JOIN parts p ON p.message_id = m.id
+       WHERE m.session_id = $1
+       GROUP BY m.id`,
+      [session.id]
+    )
+
+    stats.totalMessages += msgResult.rows.length
+
+    for (const msg of msgResult.rows) {
+      if (msg.role === "assistant" && msg.model_id) {
+        const modelKey = `${msg.provider_id || "unknown"}/${msg.model_id}`
+        if (!stats.modelUsage[modelKey]) {
+          stats.modelUsage[modelKey] = {
+            messages: 0,
+            tokens: { input: 0, output: 0, cache: { read: 0, write: 0 } },
+            cost: 0,
+          }
+        }
+        stats.modelUsage[modelKey].messages++
+        stats.modelUsage[modelKey].cost += parseFloat(msg.cost_usd) || 0
+        stats.modelUsage[modelKey].tokens.input += parseInt(msg.tokens_input) || 0
+        stats.modelUsage[modelKey].tokens.output += parseInt(msg.tokens_output) || 0
+      }
+
+      // Count tool usage from part types
+      const partTypes: string[] = msg.part_types || []
+      for (const pt of partTypes) {
+        if (pt === "tool_invocation") {
+          // We'd need to join parts.data to get tool names — approximate with "tool_call"
+          stats.toolUsage["tool_call"] = (stats.toolUsage["tool_call"] || 0) + 1
+        }
+      }
+    }
+
+    // More accurate tool usage: query parts directly
+    const toolResult = await pool.query(
+      `SELECT data->>'tool_name' as tool_name, COUNT(*) as cnt
+       FROM parts
+       WHERE session_id = $1 AND part_type = 'tool_invocation' AND data->>'tool_name' IS NOT NULL
+       GROUP BY data->>'tool_name'`,
+      [session.id]
+    )
+    // Reset the approximate count and use real data
+    delete stats.toolUsage["tool_call"]
+    for (const row of toolResult.rows) {
+      if (row.tool_name) {
+        stats.toolUsage[row.tool_name] = (stats.toolUsage[row.tool_name] || 0) + parseInt(row.cnt)
+      }
+    }
+  }
+
+  const rangeDays = Math.max(1, Math.ceil((latestTime - earliestTime) / MS_IN_DAY))
+  const effectiveDays = windowDays ?? rangeDays
+  stats.dateRange = { earliest: earliestTime, latest: latestTime }
+  stats.days = effectiveDays
+  stats.costPerDay = stats.totalCost / effectiveDays
+
+  const totalTokens = stats.totalTokens.input + stats.totalTokens.output + stats.totalTokens.reasoning +
+    stats.totalTokens.cache.read + stats.totalTokens.cache.write
+  stats.tokensPerSession = sessions.length > 0 ? totalTokens / sessions.length : 0
+
+  sessionTotalTokens.sort((a, b) => a - b)
+  const mid = Math.floor(sessionTotalTokens.length / 2)
+  stats.medianTokensPerSession = sessionTotalTokens.length === 0
+    ? 0
+    : sessionTotalTokens.length % 2 === 0
+      ? ((sessionTotalTokens[mid - 1] ?? 0) + (sessionTotalTokens[mid] ?? 0)) / 2
+      : (sessionTotalTokens[mid] ?? 0)
+
+  return stats
+}
+
+export function displayStats(stats: SessionStats, toolLimit?: number, modelLimit?: number) {
+  const width = 56
+
+  function renderRow(label: string, value: string): string {
+    const availableWidth = width - 1
+    const paddingNeeded = availableWidth - label.length - value.length
+    const padding = Math.max(0, paddingNeeded)
+    return `│${label}${" ".repeat(padding)}${value} │`
+  }
+
+  console.log("┌────────────────────────────────────────────────────────┐")
+  console.log("│                       OVERVIEW                         │")
+  console.log("├────────────────────────────────────────────────────────┤")
+  console.log(renderRow("Sessions", stats.totalSessions.toLocaleString()))
+  console.log(renderRow("Messages", stats.totalMessages.toLocaleString()))
+  console.log(renderRow("Days", stats.days.toString()))
+  console.log("└────────────────────────────────────────────────────────┘")
+  console.log()
+
+  console.log("┌────────────────────────────────────────────────────────┐")
+  console.log("│                    COST & TOKENS                       │")
+  console.log("├────────────────────────────────────────────────────────┤")
+  const cost = isNaN(stats.totalCost) ? 0 : stats.totalCost
+  const costPerDay = isNaN(stats.costPerDay) ? 0 : stats.costPerDay
+  const tokensPerSession = isNaN(stats.tokensPerSession) ? 0 : stats.tokensPerSession
+  console.log(renderRow("Total Cost", `$${cost.toFixed(2)}`))
+  console.log(renderRow("Avg Cost/Day", `$${costPerDay.toFixed(2)}`))
+  console.log(renderRow("Avg Tokens/Session", formatNumber(Math.round(tokensPerSession))))
+  const medianTokensPerSession = isNaN(stats.medianTokensPerSession) ? 0 : stats.medianTokensPerSession
+  console.log(renderRow("Median Tokens/Session", formatNumber(Math.round(medianTokensPerSession))))
+  console.log(renderRow("Input", formatNumber(stats.totalTokens.input)))
+  console.log(renderRow("Output", formatNumber(stats.totalTokens.output)))
+  console.log(renderRow("Cache Read", formatNumber(stats.totalTokens.cache.read)))
+  console.log(renderRow("Cache Write", formatNumber(stats.totalTokens.cache.write)))
+  console.log("└────────────────────────────────────────────────────────┘")
+  console.log()
+
+  if (modelLimit !== undefined && Object.keys(stats.modelUsage).length > 0) {
+    const sortedModels = Object.entries(stats.modelUsage).sort(([, a], [, b]) => b.messages - a.messages)
+    const modelsToDisplay = modelLimit === Infinity ? sortedModels : sortedModels.slice(0, modelLimit)
+
+    console.log("┌────────────────────────────────────────────────────────┐")
+    console.log("│                      MODEL USAGE                       │")
+    console.log("├────────────────────────────────────────────────────────┤")
+
+    for (const [model, usage] of modelsToDisplay) {
+      console.log(`│ ${model.padEnd(54)} │`)
+      console.log(renderRow("  Messages", usage.messages.toLocaleString()))
+      console.log(renderRow("  Input Tokens", formatNumber(usage.tokens.input)))
+      console.log(renderRow("  Output Tokens", formatNumber(usage.tokens.output)))
+      console.log(renderRow("  Cost", `$${usage.cost.toFixed(4)}`))
+      console.log("├────────────────────────────────────────────────────────┤")
+    }
+    process.stdout.write("\x1B[1A")
+    console.log("└────────────────────────────────────────────────────────┘")
+  }
+  console.log()
+
+  if (Object.keys(stats.toolUsage).length > 0) {
+    const sortedTools = Object.entries(stats.toolUsage).sort(([, a], [, b]) => b - a)
+    const toolsToDisplay = toolLimit ? sortedTools.slice(0, toolLimit) : sortedTools
+
+    console.log("┌────────────────────────────────────────────────────────┐")
+    console.log("│                      TOOL USAGE                        │")
+    console.log("├────────────────────────────────────────────────────────┤")
+
+    const maxCount = Math.max(...toolsToDisplay.map(([, count]) => count))
+    const totalToolUsage = Object.values(stats.toolUsage).reduce((a, b) => a + b, 0)
+
+    for (const [tool, count] of toolsToDisplay) {
+      const barLength = Math.max(1, Math.floor((count / maxCount) * 20))
+      const bar = "█".repeat(barLength)
+      const percentage = ((count / totalToolUsage) * 100).toFixed(1)
+      const maxToolLength = 18
+      const truncatedTool = tool.length > maxToolLength ? tool.substring(0, maxToolLength - 2) + ".." : tool
+      const toolName = truncatedTool.padEnd(maxToolLength)
+      const content = ` ${toolName} ${bar.padEnd(20)} ${count.toString().padStart(3)} (${percentage.padStart(4)}%)`
+      const padding = Math.max(0, width - content.length - 1)
+      console.log(`│${content}${" ".repeat(padding)} │`)
+    }
+    console.log("└────────────────────────────────────────────────────────┘")
+  }
+  console.log()
+}
+
+function formatNumber(num: number): string {
+  if (num >= 1_000_000) return (num / 1_000_000).toFixed(1) + "M"
+  if (num >= 1_000) return (num / 1_000).toFixed(1) + "K"
+  return num.toString()
+}