Add overview token cost breakdown

Author: Chipagosfinest

Sources/CodexBar/StatusItemController+Menu.swift

@@ -579,7 +579,7 @@ extension StatusItemController {
         let spendModel = self.overviewSpendDashboardModel(providers: enabledProviders)
         let spendSummary = OverviewSpendSummary(
             model: spendModel,
-            connectedProviderCount: enabledProviders.count)
+            trackedProviders: enabledProviders)
         let fallbackCurrencyCode = spendModel.groups.first?.currencyCode ?? "USD"
         let sharePayload = ShareStatsBuilder.make(
             model: spendModel,
@@ -609,6 +609,7 @@ extension StatusItemController {
                 spendSummary.primarySpendText,
                 spendSummary.coverageText,
                 spendSummary.tokenText ?? "",
+                spendSummary.tokenAllocation == nil ? "noAllocation" : "allocation",
             ].joined(separator: "|"),
             containsInteractiveControls: sharePayload != nil)
         menu.addItem(summaryItem)

Sources/CodexBar/StatusItemController+MenuTypes.swift

@@ -33,25 +33,108 @@ extension ProviderSwitcherSelection {
     }
 }
 
+struct OverviewTokenAllocation: Equatable {
+    struct CostPerMillionTokens: Equatable {
+        let amount: Double
+        let currencyCode: String
+    }
+
+    struct Row: Identifiable, Equatable {
+        let id: String
+        let provider: UsageProvider
+        let displayName: String
+        let tokenCount: Int?
+        let tokenFraction: Double?
+        let costPerMillionTokens: CostPerMillionTokens?
+    }
+
+    let knownTotalTokens: Int
+    let isPartial: Bool
+    let rows: [Row]
+
+    init?(model: SpendDashboardModel, trackedProviders: Set<UsageProvider>) {
+        let sourceRows = model.groups.flatMap { group in
+            group.providers.map { row in
+                (row: row, currencyCode: group.currencyCode)
+            }
+        }
+        var knownTotalTokens = 0
+        for source in sourceRows {
+            guard let tokens = source.row.totalTokens else { continue }
+            guard tokens >= 0 else { return nil }
+            let result = knownTotalTokens.addingReportingOverflow(tokens)
+            guard !result.overflow else { return nil }
+            knownTotalTokens = result.partialValue
+        }
+        guard knownTotalTokens > 0 else { return nil }
+
+        self.knownTotalTokens = knownTotalTokens
+        self.isPartial = Set(sourceRows.map(\.row.provider)) != trackedProviders ||
+            sourceRows.contains { $0.row.totalTokens == nil || $0.row.coveredDayCount < model.requestedDays } ||
+            model.groups.contains { $0.coveredDayCount < model.requestedDays }
+        self.rows = sourceRows.map { source in
+            let tokenFraction = source.row.totalTokens.map {
+                Double($0) / Double(knownTotalTokens)
+            }
+            return Row(
+                id: source.row.id,
+                provider: source.row.provider,
+                displayName: source.row.displayName,
+                tokenCount: source.row.totalTokens,
+                tokenFraction: tokenFraction,
+                costPerMillionTokens: Self.costPerMillionTokens(
+                    tokens: source.row.totalTokens,
+                    cost: source.row.totalCost,
+                    currencyCode: source.currencyCode))
+        }
+    }
+
+    private static func costPerMillionTokens(
+        tokens: Int?,
+        cost: Double?,
+        currencyCode: String) -> CostPerMillionTokens?
+    {
+        guard let tokens, tokens > 0,
+              let cost, cost.isFinite, cost >= 0,
+              !currencyCode.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty
+        else { return nil }
+        let amount = (cost / Double(tokens)) * 1_000_000
+        guard amount.isFinite, amount >= 0 else { return nil }
+        return CostPerMillionTokens(amount: amount, currencyCode: currencyCode)
+    }
+}
+
 struct OverviewSpendSummary: Equatable {
     let primarySpendText: String
     let coverageText: String
     let tokenText: String?
+    let tokenAllocation: OverviewTokenAllocation?
     let isPartial: Bool
 
-    init(model: SpendDashboardModel, connectedProviderCount: Int) {
-        let connectedCount = max(0, connectedProviderCount)
-        let knownCostCount = model.groups.reduce(0) { $0 + $1.knownCostProviderCount }
-        let knownTokenRows = model.groups.flatMap(\.providers).compactMap(\.totalTokens)
+    init(model: SpendDashboardModel, trackedProviders: [UsageProvider]) {
+        let trackedProviderSet = Set(trackedProviders)
+        let connectedCount = trackedProviderSet.count
+        let sourceRows = model.groups.flatMap(\.providers)
+        let rowsByProvider = Dictionary(grouping: sourceRows, by: \.provider)
+        let modeledProviderSet = Set(rowsByProvider.keys)
+        let knownCostProviderSet = Set(rowsByProvider.compactMap { provider, rows in
+            rows.allSatisfy { $0.totalCost != nil } ? provider : nil
+        })
+        let knownCostCount = knownCostProviderSet.intersection(trackedProviderSet).count
+        let costCoverageIsComplete = modeledProviderSet == trackedProviderSet &&
+            knownCostProviderSet == trackedProviderSet &&
+            model.groups.allSatisfy { $0.totalCost != nil }
+        let knownTokenRows = sourceRows.compactMap(\.totalTokens)
         let knownTokens = Self.safeTokenSum(knownTokenRows)
-        let tokenCoverageIsComplete = knownTokenRows.count == connectedCount &&
+        let tokenCoverageIsComplete = modeledProviderSet == trackedProviderSet &&
+            sourceRows.allSatisfy { $0.totalTokens != nil && $0.coveredDayCount >= model.requestedDays } &&
             model.groups.allSatisfy { $0.totalTokens != nil }
-        self.isPartial = knownCostCount < connectedCount || model.groups.contains { $0.totalCost == nil }
+        self.isPartial = !costCoverageIsComplete
 
         let spendTexts = model.groups.compactMap { group -> String? in
             guard let cost = group.totalCost ?? group.knownCost else { return nil }
             let formatted = UsageFormatter.currencyString(cost, currencyCode: group.currencyCode)
-            let groupIsPartial = group.totalCost == nil || knownCostCount < connectedCount
+            let groupIsPartial = group.totalCost == nil || !costCoverageIsComplete
             return groupIsPartial ? "~\(formatted)" : formatted
         }
         self.primarySpendText = spendTexts.isEmpty ? L("Spend unavailable") : spendTexts.joined(separator: " · ")
@@ -62,6 +145,7 @@ struct OverviewSpendSummary: Equatable {
             let value = tokenCoverageIsComplete ? formatted : "~\(formatted)"
             return L("%@ tokens", value)
         }
+        self.tokenAllocation = OverviewTokenAllocation(model: model, trackedProviders: trackedProviderSet)
     }
 
     private static func safeTokenSum(_ values: [Int]) -> Int? {
@@ -76,7 +160,8 @@ struct OverviewSpendSummary: Equatable {
 }
 
 struct OverviewSpendSummaryCardView: View {
-    static let rowHeight: CGFloat = 94
+    static let baseRowHeight: CGFloat = 94
+    static let rowHeight: CGFloat = 146
 
     let summary: OverviewSpendSummary
     let days: Int
@@ -110,6 +195,10 @@ struct OverviewSpendSummaryCardView: View {
                 .font(.caption)
                 .foregroundStyle(.secondary)
                 .lineLimit(1)
+
+                if let allocation = self.summary.tokenAllocation {
+                    OverviewTokenAllocationView(allocation: allocation)
+                }
             }
 
             Spacer(minLength: 6)
@@ -130,7 +219,9 @@ struct OverviewSpendSummaryCardView: View {
         .padding(.horizontal, UsageMenuCardLayout.horizontalPadding)
         .padding(.vertical, 10)
         .frame(width: self.width, alignment: .leading)
-        .frame(minHeight: Self.rowHeight, alignment: .leading)
+        .frame(
+            minHeight: self.summary.tokenAllocation == nil ? Self.baseRowHeight : Self.rowHeight,
+            alignment: .leading)
         .background {
             RoundedRectangle(cornerRadius: 12, style: .continuous)
                 .fill(Color.accentColor.opacity(0.08))
@@ -139,6 +230,142 @@ struct OverviewSpendSummaryCardView: View {
     }
 }
 
+private struct OverviewTokenAllocationView: View {
+    private static let displayLimit = 3
+    private static let segmentSpacing: CGFloat = 1
+
+    let allocation: OverviewTokenAllocation
+    @Environment(\.accessibilityReduceMotion) private var reduceMotion
+
+    var body: some View {
+        VStack(alignment: .leading, spacing: 4) {
+            HStack(spacing: 5) {
+                Text(L("Tracked tokens"))
+                Spacer(minLength: 4)
+                Text(
+                    (self.allocation.isPartial ? "~" : "") +
+                        ShareStatsFormatting.compactCount(self.allocation.knownTotalTokens))
+                    .monospacedDigit()
+            }
+            .font(.caption2.weight(.medium))
+            .foregroundStyle(.secondary)
+
+            self.segmentedBar
+                .frame(height: 6)
+
+            HStack(alignment: .firstTextBaseline, spacing: 8) {
+                ForEach(Array(self.visibleRows.enumerated()), id: \.offset) { _, row in
+                    VStack(alignment: .leading, spacing: 1) {
+                        Text(self.allocationText(for: row))
+                            .font(.caption2.weight(.semibold))
+                            .lineLimit(1)
+                        Text(self.rateText(for: row))
+                            .font(.caption2)
+                            .foregroundStyle(.secondary)
+                            .lineLimit(1)
+                    }
+                    .frame(maxWidth: .infinity, alignment: .leading)
+                    .accessibilityElement(children: .ignore)
+                    .accessibilityLabel(self.accessibilityText(for: row))
+                }
+                if self.hiddenRowCount > 0 {
+                    Text("+\(self.hiddenRowCount)")
+                        .font(.caption2.weight(.medium))
+                        .foregroundStyle(.secondary)
+                        .accessibilityLabel(L("%d more items", self.hiddenRowCount))
+                }
+            }
+        }
+        .animation(
+            self.reduceMotion ? nil : .easeOut(duration: 0.2),
+            value: self.allocation.rows)
+    }
+
+    private var segmentedBar: some View {
+        GeometryReader { geometry in
+            let rows = self.segmentRows
+            let spacing = Self.segmentSpacing * CGFloat(max(0, rows.count - 1))
+            let availableWidth = max(0, geometry.size.width - spacing)
+            HStack(spacing: Self.segmentSpacing) {
+                ForEach(Array(rows.enumerated()), id: \.offset) { _, row in
+                    RoundedRectangle(cornerRadius: 3, style: .continuous)
+                        .fill(UsageMenuCardView.Model.progressColor(for: row.provider))
+                        .frame(width: availableWidth * (row.tokenFraction ?? 0))
+                }
+            }
+        }
+        .background(Color.primary.opacity(0.08), in: RoundedRectangle(cornerRadius: 3, style: .continuous))
+        .accessibilityElement(children: .ignore)
+        .accessibilityLabel("\(L("Tracked tokens")) · \(L("Usage breakdown"))")
+        .accessibilityValue(self.accessibilityAllocationValue)
+    }
+
+    private var orderedRows: [OverviewTokenAllocation.Row] {
+        self.allocation.rows.sorted { lhs, rhs in
+            switch (lhs.tokenCount, rhs.tokenCount) {
+            case let (left?, right?) where left != right: left > right
+            case (_?, nil): true
+            case (nil, _?): false
+            default: lhs.id < rhs.id
+            }
+        }
+    }
+
+    private var visibleRows: [OverviewTokenAllocation.Row] {
+        Array(self.orderedRows.prefix(Self.displayLimit))
+    }
+
+    private var hiddenRowCount: Int {
+        max(0, self.allocation.rows.count - self.visibleRows.count)
+    }
+
+    private var segmentRows: [OverviewTokenAllocation.Row] {
+        self.orderedRows.filter { ($0.tokenFraction ?? 0) > 0 }
+    }
+
+    private var accessibilityAllocationValue: String {
+        self.allocation.rows.map(self.accessibilityText).joined(separator: ", ")
+    }
+
+    private func allocationText(for row: OverviewTokenAllocation.Row) -> String {
+        let percent = row.tokenFraction.map { UsageFormatter.percentString($0 * 100) } ?? L("Unknown")
+        return "\(row.displayName) \(percent)"
+    }
+
+    private func rateText(for row: OverviewTokenAllocation.Row) -> String {
+        guard let rate = row.costPerMillionTokens else { return L("unavailable") }
+        return OverviewTokenRateFormatting.text(rate)
+    }
+
+    private func accessibilityText(for row: OverviewTokenAllocation.Row) -> String {
+        "\(self.allocationText(for: row)), \(self.rateText(for: row))"
+    }
+}
+
+enum OverviewTokenRateFormatting {
+    static func text(_ rate: OverviewTokenAllocation.CostPerMillionTokens) -> String {
+        let formatted = UsageFormatter.currencyString(rate.amount, currencyCode: rate.currencyCode)
+        let zero = UsageFormatter.currencyString(0, currencyCode: rate.currencyCode)
+        if rate.amount > 0, formatted == zero {
+            let minimum = self.minimumVisibleAmount(currencyCode: rate.currencyCode)
+            return "<\(UsageFormatter.currencyString(minimum, currencyCode: rate.currencyCode)) / 1M"
+        }
+        return "\(rate.amount == 0 ? "" : "~")\(formatted) / 1M"
+    }
+
+    private static func minimumVisibleAmount(currencyCode: String) -> Double {
+        let zero = UsageFormatter.currencyString(0, currencyCode: currencyCode)
+        var candidate = 1.0
+        var minimum = candidate
+        for _ in 0..<8 {
+            guard UsageFormatter.currencyString(candidate, currencyCode: currencyCode) != zero else { break }
+            minimum = candidate
+            candidate /= 10
+        }
+        return minimum
+    }
+}
+
 struct OverviewMenuCardRowView: View {
     enum Emphasis: Equatable {
         case prominent