@sriinnu/runic 2.0.0 → 2.11.2

package/Sources/Runic/Views/Menu/ModelBreakdownMenuView.swift

@@ -1,241 +0,0 @@
-import Charts
-import RunicCore
-import SwiftUI
-
-@MainActor
-struct ModelBreakdownMenuView: View {
-    private let breakdown: [UsageLedgerModelSummary]
-    private let width: CGFloat
-
-    /// Maximum number of models to show before truncating.
-    private static let maxDisplayed = 10
-
-    init(breakdown: [UsageLedgerModelSummary], width: CGFloat) {
-        self.breakdown = breakdown
-        self.width = width
-    }
-
-    var body: some View {
-        let model = Self.makeModel(from: self.breakdown)
-        VStack(alignment: .leading, spacing: RunicSpacing.sm) {
-            if model.items.isEmpty {
-                Text("No model data.")
-                    .font(RunicFont.footnote)
-                    .foregroundStyle(.secondary)
-            } else {
-                // MARK: - Title
-
-                Text("Models")
-                    .font(RunicFont.caption)
-                    .fontWeight(.semibold)
-                    .foregroundStyle(.primary)
-
-                // MARK: - Donut chart
-
-                Chart {
-                    ForEach(model.chartItems) { item in
-                        SectorMark(
-                            angle: .value("Tokens", item.totalTokens),
-                            innerRadius: .ratio(0.55),
-                            angularInset: 1.0)
-                            .foregroundStyle(item.color)
-                    }
-                }
-                .chartLegend(.hidden)
-                .frame(height: 100)
-                .accessibilityElement(children: .ignore)
-                .accessibilityLabel(Self.chartAccessibilityLabel(model: model))
-
-                // MARK: - Model list
-
-                VStack(alignment: .leading, spacing: RunicSpacing.xxs) {
-                    ForEach(model.chartItems) { item in
-                        Self.modelRow(item: item)
-                    }
-                }
-
-                // MARK: - Overflow note
-
-                if model.overflowCount > 0 {
-                    Text("and \(model.overflowCount) more")
-                        .font(RunicFont.caption2)
-                        .foregroundStyle(.tertiary)
-                }
-
-                // MARK: - Cache hit rate
-
-                if let cacheRate = model.cacheHitRateText {
-                    Divider()
-                    HStack(spacing: RunicSpacing.xxs) {
-                        Text("Cache hit rate")
-                            .font(RunicFont.caption)
-                            .foregroundStyle(.secondary)
-                        Spacer(minLength: RunicSpacing.xxs)
-                        Text(cacheRate)
-                            .font(RunicFont.caption)
-                            .fontWeight(.medium)
-                            .foregroundStyle(.primary)
-                    }
-                }
-
-                // MARK: - Total summary
-
-                Divider()
-                Self.totalRow(model: model)
-            }
-        }
-        .padding(.horizontal, MenuCardMetrics.horizontalPadding)
-        .padding(.vertical, RunicSpacing.xs)
-        .frame(minWidth: self.width, maxWidth: .infinity, alignment: .leading)
-    }
-
-    // MARK: - Row views
-
-    private static func modelRow(item: ModelItem) -> some View {
-        HStack(spacing: RunicSpacing.xxs) {
-            Circle()
-                .fill(item.color)
-                .frame(width: RunicSpacing.chartLegendDot, height: RunicSpacing.chartLegendDot)
-            Text(item.displayName)
-                .font(RunicFont.caption)
-                .foregroundStyle(.primary)
-                .lineLimit(1)
-                .truncationMode(.tail)
-            Spacer(minLength: RunicSpacing.xxs)
-            VStack(alignment: .trailing, spacing: 0) {
-                Text("\(UsageFormatter.tokenCountString(item.totalTokens)) tokens")
-                    .font(RunicFont.caption2)
-                    .foregroundStyle(.secondary)
-                if let context = UsageFormatter.modelContextLabel(for: item.model) {
-                    Text(context)
-                        .font(RunicFont.caption2)
-                        .foregroundStyle(.tertiary)
-                }
-                HStack(spacing: RunicSpacing.xxxs) {
-                    Text("\(item.requestCount) req\(item.requestCount == 1 ? "" : "s")")
-                        .font(RunicFont.caption2)
-                        .foregroundStyle(.tertiary)
-                    if let cost = item.costText {
-                        Text(cost)
-                            .font(RunicFont.caption2)
-                            .foregroundStyle(.tertiary)
-                    }
-                }
-            }
-        }
-    }
-
-    private static func totalRow(model: ModelModel) -> some View {
-        HStack {
-            Text("Total")
-                .font(RunicFont.caption)
-                .fontWeight(.medium)
-                .foregroundStyle(.primary)
-            Spacer(minLength: RunicSpacing.xxs)
-            VStack(alignment: .trailing, spacing: 0) {
-                Text("\(UsageFormatter.tokenCountString(model.grandTotalTokens)) tokens")
-                    .font(RunicFont.caption2)
-                    .foregroundStyle(.secondary)
-                HStack(spacing: RunicSpacing.xxxs) {
-                    Text("\(model.grandTotalRequests) requests")
-                        .font(RunicFont.caption2)
-                        .foregroundStyle(.tertiary)
-                    if let cost = model.grandTotalCostText {
-                        Text(cost)
-                            .font(RunicFont.caption2)
-                            .foregroundStyle(.tertiary)
-                    }
-                }
-            }
-        }
-    }
-
-    // MARK: - Model
-
-    struct ModelItem: Identifiable {
-        let id: String
-        let displayName: String
-        let model: String
-        let totalTokens: Int
-        let requestCount: Int
-        let costText: String?
-        let color: Color
-    }
-
-    struct ModelModel {
-        let items: [ModelItem]
-        let chartItems: [ModelItem]
-        let overflowCount: Int
-        let grandTotalTokens: Int
-        let grandTotalRequests: Int
-        let grandTotalCostText: String?
-        let cacheHitRateText: String?
-    }
-
-    private static func chartAccessibilityLabel(model: ModelModel) -> String {
-        guard !model.chartItems.isEmpty else { return "Model breakdown chart, no data" }
-
-        let modelCount = model.items.count
-        let totalTokens = UsageFormatter.tokenCountString(model.grandTotalTokens)
-
-        let topItems = model.chartItems.prefix(3).map { item -> String in
-            let pct = model.grandTotalTokens > 0
-                ? Double(item.totalTokens) / Double(model.grandTotalTokens) * 100
-                : 0
-            return "\(item.displayName) \(String(format: "%.0f", pct))%"
-        }
-
-        var label = "Model breakdown: \(modelCount) model\(modelCount == 1 ? "" : "s"), \(totalTokens) tokens total"
-        if !topItems.isEmpty {
-            label += ", \(topItems.joined(separator: ", "))"
-        }
-        if let cacheRate = model.cacheHitRateText {
-            label += ", cache hit rate \(cacheRate)"
-        }
-        return label
-    }
-
-    private static func makeModel(from breakdown: [UsageLedgerModelSummary]) -> ModelModel {
-        let sorted = breakdown.sorted { lhs, rhs in
-            lhs.totals.totalTokens > rhs.totals.totalTokens
-        }
-
-        let items: [ModelItem] = sorted.enumerated().map { index, summary in
-            let displayName = UsageFormatter.modelDisplayName(summary.model)
-            let costText = summary.totals.costUSD.map { UsageFormatter.usdString($0) }
-            return ModelItem(
-                id: "\(summary.model)-\(index)",
-                displayName: displayName,
-                model: summary.model,
-                totalTokens: summary.totals.totalTokens,
-                requestCount: summary.entryCount,
-                costText: costText,
-                color: RunicColors.colorForModel(summary.model))
-        }
-
-        let displayed = Array(items.prefix(self.maxDisplayed))
-        let overflow = max(0, items.count - self.maxDisplayed)
-
-        let grandTokens = sorted.reduce(0) { $0 + $1.totals.totalTokens }
-        let grandRequests = sorted.reduce(0) { $0 + $1.entryCount }
-        let grandCost = sorted.reduce(0.0) { $0 + ($1.totals.costUSD ?? 0) }
-        let grandCostText = grandCost > 0 ? UsageFormatter.usdString(grandCost) : nil
-
-        // Cache hit rate: cacheReadTokens / totalTokens across all models
-        let totalCacheRead = sorted.reduce(0) { $0 + $1.totals.cacheReadTokens }
-        let cacheHitRateText: String? = if grandTokens > 0, totalCacheRead > 0 {
-            String(format: "%.1f%%", Double(totalCacheRead) / Double(grandTokens) * 100)
-        } else {
-            nil
-        }
-
-        return ModelModel(
-            items: items,
-            chartItems: displayed,
-            overflowCount: overflow,
-            grandTotalTokens: grandTokens,
-            grandTotalRequests: grandRequests,
-            grandTotalCostText: grandCostText,
-            cacheHitRateText: cacheHitRateText)
-    }
-}

package/Sources/Runic/Views/Menu/OverviewMenuView.swift

@@ -1,281 +0,0 @@
-import AppKit
-import Charts
-import RunicCore
-import SwiftUI
-
-/// Overview dashboard showing all enabled providers at a glance.
-/// Inspired by Apple Activity app rings, Awwwards dashboard layouts, and Tokex stat cards.
-@MainActor
-struct OverviewMenuView: View {
-    struct ProviderSummary: Identifiable {
-        let id: String
-        let provider: UsageProvider
-        let name: String
-        let icon: NSImage?
-        let usedPercent: Double
-        let todayTokens: Int
-        let brandColor: Color
-        let resetDescription: String?
-        let windowLabel: String? // e.g. "5h" or "Weekly"
-        let topModelContext: String? // e.g. "200K ctx"
-    }
-
-    struct DailyPoint: Identifiable {
-        let id: String
-        let date: Date
-        let tokens: Int
-        let provider: String
-        let color: Color
-    }
-
-    let summaries: [ProviderSummary]
-    let chartPoints: [DailyPoint]
-    let totalTodayTokens: Int
-    let totalProviders: Int
-    let width: CGFloat
-
-    var body: some View {
-        VStack(alignment: .leading, spacing: RunicSpacing.sm) {
-            // MARK: - Hero header
-
-            HStack(alignment: .center, spacing: RunicSpacing.xs) {
-                // Ring indicator showing overall usage
-                ZStack {
-                    Circle()
-                        .stroke(Color(nsColor: .separatorColor).opacity(0.15), lineWidth: 3)
-                    Circle()
-                        .trim(from: 0, to: min(1, self.averageUsedPercent / 100))
-                        .stroke(
-                            AngularGradient(
-                                colors: [RunicColors.chartColor(at: 4), RunicColors.chartColor(at: 0)],
-                                center: .center),
-                            style: StrokeStyle(lineWidth: 3, lineCap: .round))
-                        .rotationEffect(.degrees(-90))
-                }
-                .frame(width: 32, height: 32)
-
-                VStack(alignment: .leading, spacing: 0) {
-                    Text(UsageFormatter.tokenCountString(self.totalTodayTokens))
-                        .font(RunicFont.system(size: 22, weight: .bold))
-                    Text("\(self.summaries.count) of \(self.totalProviders) active")
-                        .font(RunicFont.caption2)
-                        .foregroundStyle(.tertiary)
-                }
-
-                Spacer()
-
-                VStack(alignment: .trailing, spacing: 2) {
-                    Text("today")
-                        .font(RunicFont.caption2)
-                        .foregroundStyle(.tertiary)
-                    Text("\(Int(self.averageUsedPercent))% avg")
-                        .font(RunicFont.caption)
-                        .fontWeight(.medium)
-                        .foregroundStyle(.secondary)
-                }
-            }
-
-            Divider().opacity(0.5)
-
-            // MARK: - Provider cards
-
-            if self.summaries.isEmpty {
-                Text("No active providers.")
-                    .font(RunicFont.footnote)
-                    .foregroundStyle(.secondary)
-                    .frame(maxWidth: .infinity, alignment: .center)
-                    .padding(.vertical, RunicSpacing.md)
-            } else {
-                VStack(spacing: RunicSpacing.compact) {
-                    ForEach(self.summaries) { summary in
-                        ProviderRow(summary: summary)
-                    }
-                }
-            }
-
-            // MARK: - Combined 7-day chart
-
-            if !self.chartPoints.isEmpty {
-                Divider().opacity(0.5)
-
-                HStack {
-                    Text("7-day activity")
-                        .font(RunicFont.caption2)
-                        .foregroundStyle(.tertiary)
-                    Spacer()
-                    // Mini legend dots
-                    HStack(spacing: RunicSpacing.xxs) {
-                        ForEach(self.summaries.prefix(4)) { s in
-                            Circle()
-                                .fill(s.brandColor)
-                                .frame(width: 5, height: 5)
-                        }
-                        if self.summaries.count > 4 {
-                            Text("+\(self.summaries.count - 4)")
-                                .font(RunicFont.system(size: 8))
-                                .foregroundStyle(.quaternary)
-                        }
-                    }
-                }
-
-                Chart {
-                    ForEach(self.chartPoints) { point in
-                        BarMark(
-                            x: .value("Date", point.date, unit: .day),
-                            y: .value("Tokens", point.tokens))
-                            .foregroundStyle(by: .value("Provider", point.provider))
-                            .cornerRadius(2)
-                    }
-                }
-                .chartForegroundStyleScale(range: self.chartColors)
-                .chartLegend(.hidden)
-                .chartYAxis {
-                    AxisMarks(position: .trailing, values: .automatic(desiredCount: 3)) { value in
-                        AxisGridLine(stroke: StrokeStyle(lineWidth: 0.3, dash: [3, 3]))
-                            .foregroundStyle(Color(nsColor: .separatorColor).opacity(0.3))
-                        AxisValueLabel {
-                            if let tokens = value.as(Int.self) {
-                                Text(UsageFormatter.tokenCountString(tokens))
-                                    .font(RunicFont.system(size: 8))
-                                    .foregroundStyle(Color(nsColor: .tertiaryLabelColor))
-                            }
-                        }
-                    }
-                }
-                .chartXAxis {
-                    AxisMarks(values: .automatic(desiredCount: 7)) { _ in
-                        AxisValueLabel(format: .dateTime.weekday(.narrow))
-                            .font(RunicFont.system(size: 8, weight: .medium))
-                            .foregroundStyle(Color(nsColor: .tertiaryLabelColor))
-                    }
-                }
-                .frame(height: 80)
-            }
-        }
-        .padding(.horizontal, MenuCardMetrics.horizontalPadding)
-        .padding(.vertical, RunicSpacing.sm)
-        .frame(minWidth: self.width, maxWidth: .infinity, alignment: .leading)
-    }
-
-    private var averageUsedPercent: Double {
-        let active = self.summaries.filter { $0.usedPercent > 0 }
-        guard !active.isEmpty else { return 0 }
-        return active.reduce(0) { $0 + $1.usedPercent } / Double(active.count)
-    }
-
-    private var chartColors: [Color] {
-        self.summaries.map(\.brandColor)
-    }
-}
-
-// MARK: - Provider row
-
-private struct ProviderRow: View {
-    let summary: OverviewMenuView.ProviderSummary
-
-    var body: some View {
-        HStack(spacing: RunicSpacing.xs) {
-            // Icon with brand tint
-            if let icon = self.summary.icon {
-                Image(nsImage: icon)
-                    .resizable()
-                    .aspectRatio(contentMode: .fit)
-                    .frame(width: 14, height: 14)
-            }
-
-            // Name
-            Text(self.summary.name)
-                .font(RunicFont.caption)
-                .fontWeight(.medium)
-                .frame(width: 58, alignment: .leading)
-                .lineLimit(1)
-
-            // Progress bar with gradient fill
-            GeometryReader { geo in
-                let fillWidth = max(0, geo.size.width * min(1, self.summary.usedPercent / 100))
-                ZStack(alignment: .leading) {
-                    // Track
-                    Capsule()
-                        .fill(Color(nsColor: .separatorColor).opacity(0.12))
-
-                    // Fill with gradient
-                    Capsule()
-                        .fill(
-                            LinearGradient(
-                                colors: [
-                                    self.summary.brandColor.opacity(0.9),
-                                    self.summary.brandColor,
-                                ],
-                                startPoint: .leading,
-                                endPoint: .trailing))
-                        .frame(width: fillWidth)
-
-                    // Gloss overlay on fill
-                    Capsule()
-                        .fill(
-                            LinearGradient(
-                                stops: [
-                                    .init(color: .white.opacity(0.2), location: 0),
-                                    .init(color: .clear, location: 0.5),
-                                ],
-                                startPoint: .top,
-                                endPoint: .bottom))
-                        .frame(width: fillWidth)
-                }
-            }
-            .frame(height: 7)
-
-            // Percentage
-            Text("\(Int(self.summary.usedPercent))%")
-                .font(RunicFont.system(size: 9, weight: .semibold))
-                .foregroundStyle(self.summary.usedPercent > 80 ? .primary : .secondary)
-                .frame(width: 28, alignment: .trailing)
-
-            // Today's tokens (if any)
-            if self.summary.todayTokens > 0 {
-                Text(UsageFormatter.tokenCountString(self.summary.todayTokens))
-                    .font(RunicFont.system(size: 8))
-                    .foregroundStyle(.tertiary)
-                    .frame(width: 32, alignment: .trailing)
-            }
-        }
-
-        // Second line: window + reset + context
-        let hasSecondLine = self.summary.windowLabel != nil ||
-            self.summary.resetDescription != nil ||
-            self.summary.topModelContext != nil
-
-        if hasSecondLine {
-            HStack(spacing: RunicSpacing.xxs) {
-                // Spacer for icon + name width
-                Color.clear.frame(width: 14 + 58 + RunicSpacing.xs * 2, height: 0)
-
-                if let window = self.summary.windowLabel {
-                    InfoPill(text: window)
-                }
-                if let reset = self.summary.resetDescription {
-                    InfoPill(text: reset)
-                }
-                if let ctx = self.summary.topModelContext {
-                    InfoPill(text: ctx)
-                }
-                Spacer()
-            }
-        }
-    }
-}
-
-private struct InfoPill: View {
-    let text: String
-
-    var body: some View {
-        Text(self.text)
-            .font(RunicFont.system(size: 8, weight: .medium))
-            .foregroundStyle(.tertiary)
-            .padding(.horizontal, 4)
-            .padding(.vertical, 1)
-            .background(
-                Capsule(style: .continuous)
-                    .fill(Color(nsColor: .controlBackgroundColor).opacity(RunicColors.Opacity.subtle)))
-    }
-}