@sriinnu/runic 1.0.0

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

@@ -0,0 +1,312 @@
+import RunicCore
+import SwiftUI
+
+@MainActor
+struct EfficiencyMetricsMenuView: View {
+    enum SortColumn {
+        case model
+        case tokensPerRequest
+        case costPerRequest
+        case cacheHitRate
+
+        var label: String {
+            switch self {
+            case .model: return "Model"
+            case .tokensPerRequest: return "Tokens/Req"
+            case .costPerRequest: return "Cost/Req"
+            case .cacheHitRate: return "Cache Hit %"
+            }
+        }
+    }
+
+    fileprivate struct ModelMetrics: Identifiable {
+        let id: String
+        let modelName: String
+        let requestCount: Int
+        let tokensPerRequest: Double
+        let costPerRequest: Double?
+        let cacheHitRate: Double // 0.0-1.0
+
+        init(summary: UsageLedgerModelSummary) {
+            self.id = summary.model
+            self.modelName = summary.model
+            self.requestCount = summary.entryCount
+            self.tokensPerRequest = summary.entryCount > 0
+                ? Double(summary.totals.totalTokens) / Double(summary.entryCount)
+                : 0
+            self.costPerRequest = if let cost = summary.totals.costUSD, summary.entryCount > 0 {
+                cost / Double(summary.entryCount)
+            } else {
+                nil
+            }
+
+            let cacheTotal = summary.totals.cacheCreationTokens + summary.totals.cacheReadTokens
+            let totalTokens = summary.totals.totalTokens
+            self.cacheHitRate = totalTokens > 0 ? Double(cacheTotal) / Double(totalTokens) : 0.0
+        }
+    }
+
+    private let modelSummaries: [UsageLedgerModelSummary]
+    private let width: CGFloat
+    @State private var sortColumn: SortColumn = .tokensPerRequest
+    @State private var sortAscending = false
+    @State private var hoveredModelID: String?
+
+    init(modelSummaries: [UsageLedgerModelSummary], width: CGFloat) {
+        self.modelSummaries = modelSummaries
+        self.width = width
+    }
+
+    var body: some View {
+        let model = Self.makeModel(
+            from: self.modelSummaries,
+            sortBy: self.sortColumn,
+            ascending: self.sortAscending)
+
+        VStack(alignment: .leading, spacing: RunicSpacing.sm) {
+            Text("Efficiency Metrics")
+                .font(.headline)
+                .fontWeight(.semibold)
+
+            if model.isEmpty {
+                Text("No efficiency metrics available.")
+                    .font(.footnote)
+                    .foregroundStyle(.secondary)
+            } else {
+                VStack(alignment: .leading, spacing: RunicSpacing.xxs) {
+                    // Header
+                    HStack(spacing: 0) {
+                        SortableColumnHeader(
+                            title: "Model",
+                            column: .model,
+                            currentSort: self.sortColumn,
+                            ascending: self.sortAscending,
+                            width: 140,
+                            onSort: self.toggleSort)
+                        SortableColumnHeader(
+                            title: "Tokens/Req",
+                            column: .tokensPerRequest,
+                            currentSort: self.sortColumn,
+                            ascending: self.sortAscending,
+                            width: 90,
+                            onSort: self.toggleSort)
+                        SortableColumnHeader(
+                            title: "Cost/Req",
+                            column: .costPerRequest,
+                            currentSort: self.sortColumn,
+                            ascending: self.sortAscending,
+                            width: 80,
+                            onSort: self.toggleSort)
+                        SortableColumnHeader(
+                            title: "Cache Hit",
+                            column: .cacheHitRate,
+                            currentSort: self.sortColumn,
+                            ascending: self.sortAscending,
+                            width: 80,
+                            onSort: self.toggleSort)
+                    }
+                    .padding(.horizontal, RunicSpacing.xs)
+                    .padding(.vertical, RunicSpacing.xxs)
+                    .background(Color(nsColor: .controlBackgroundColor))
+                    .cornerRadius(RunicCornerRadius.xs)
+
+                    Divider()
+
+                    ScrollView {
+                        VStack(spacing: RunicSpacing.xxxs) {
+                            ForEach(model) { metrics in
+                                MetricsRow(
+                                    metrics: metrics,
+                                    isHovered: self.hoveredModelID == metrics.id)
+                                    .onHover { hovering in
+                                        self.hoveredModelID = hovering ? metrics.id : nil
+                                    }
+                            }
+                        }
+                    }
+                    .frame(maxHeight: 300)
+                }
+
+                // Summary stats
+                Divider()
+                    .padding(.vertical, RunicSpacing.xxs)
+
+                HStack(spacing: RunicSpacing.lg) {
+                    VStack(alignment: .leading, spacing: RunicSpacing.xxxs) {
+                        Text("Total Requests")
+                            .font(.caption2)
+                            .foregroundStyle(.secondary)
+                        Text("\(Self.totalRequests(model))")
+                            .font(.caption)
+                            .fontWeight(.medium)
+                    }
+                    VStack(alignment: .leading, spacing: RunicSpacing.xxxs) {
+                        Text("Avg Tokens/Req")
+                            .font(.caption2)
+                            .foregroundStyle(.secondary)
+                        Text(UsageFormatter.tokenCountString(Self.averageTokensPerRequest(model)))
+                            .font(.caption)
+                            .fontWeight(.medium)
+                    }
+                    if Self.hasAnyCost(model) {
+                        VStack(alignment: .leading, spacing: RunicSpacing.xxxs) {
+                            Text("Avg Cost/Req")
+                                .font(.caption2)
+                                .foregroundStyle(.secondary)
+                            Text(UsageFormatter.usdString(Self.averageCostPerRequest(model)))
+                                .font(.caption)
+                                .fontWeight(.medium)
+                        }
+                    }
+                }
+            }
+        }
+        .padding(.horizontal, MenuCardMetrics.horizontalPadding)
+        .padding(.vertical, RunicSpacing.xs)
+        .frame(minWidth: self.width, maxWidth: .infinity, alignment: .leading)
+    }
+
+    private func toggleSort(column: SortColumn) {
+        if self.sortColumn == column {
+            self.sortAscending.toggle()
+        } else {
+            self.sortColumn = column
+            self.sortAscending = false
+        }
+    }
+
+    private static func makeModel(
+        from summaries: [UsageLedgerModelSummary],
+        sortBy: SortColumn,
+        ascending: Bool) -> [ModelMetrics]
+    {
+        let metrics = summaries.map { ModelMetrics(summary: $0) }
+        let sorted = metrics.sorted { lhs, rhs in
+            let result: Bool
+            switch sortBy {
+            case .model:
+                result = lhs.modelName < rhs.modelName
+            case .tokensPerRequest:
+                result = lhs.tokensPerRequest < rhs.tokensPerRequest
+            case .costPerRequest:
+                let lhsCost = lhs.costPerRequest ?? 0
+                let rhsCost = rhs.costPerRequest ?? 0
+                result = lhsCost < rhsCost
+            case .cacheHitRate:
+                result = lhs.cacheHitRate < rhs.cacheHitRate
+            }
+            return ascending ? result : !result
+        }
+        return sorted
+    }
+
+    private static func totalRequests(_ metrics: [ModelMetrics]) -> Int {
+        metrics.reduce(0) { $0 + $1.requestCount }
+    }
+
+    private static func averageTokensPerRequest(_ metrics: [ModelMetrics]) -> Int {
+        let totalTokens = metrics.reduce(0.0) { $0 + ($1.tokensPerRequest * Double($1.requestCount)) }
+        let totalRequests = totalRequests(metrics)
+        return totalRequests > 0 ? Int(totalTokens / Double(totalRequests)) : 0
+    }
+
+    private static func averageCostPerRequest(_ metrics: [ModelMetrics]) -> Double {
+        let totalCost = metrics.reduce(0.0) { sum, m in
+            sum + ((m.costPerRequest ?? 0) * Double(m.requestCount))
+        }
+        let totalRequests = totalRequests(metrics)
+        return totalRequests > 0 ? totalCost / Double(totalRequests) : 0
+    }
+
+    private static func hasAnyCost(_ metrics: [ModelMetrics]) -> Bool {
+        metrics.contains { $0.costPerRequest != nil }
+    }
+}
+
+private struct SortableColumnHeader: View {
+    let title: String
+    let column: EfficiencyMetricsMenuView.SortColumn
+    let currentSort: EfficiencyMetricsMenuView.SortColumn
+    let ascending: Bool
+    let width: CGFloat
+    let onSort: (EfficiencyMetricsMenuView.SortColumn) -> Void
+
+    var body: some View {
+        Button {
+            self.onSort(self.column)
+        } label: {
+            HStack(spacing: RunicSpacing.xxs) {
+                Text(self.title)
+                    .font(.caption)
+                    .foregroundStyle(.secondary)
+                    .fontWeight(.medium)
+                if self.currentSort == self.column {
+                    Image(systemName: self.ascending ? "chevron.up" : "chevron.down")
+                        .font(.caption2)
+                        .foregroundStyle(.secondary)
+                }
+            }
+            .frame(width: self.width, alignment: .leading)
+        }
+        .buttonStyle(.plain)
+    }
+}
+
+private struct MetricsRow: View {
+    let metrics: EfficiencyMetricsMenuView.ModelMetrics
+    let isHovered: Bool
+
+    var body: some View {
+        HStack(spacing: 0) {
+            VStack(alignment: .leading, spacing: RunicSpacing.xxxs) {
+                Text(UsageFormatter.modelDisplayName(metrics.modelName))
+                    .font(.caption)
+                    .lineLimit(1)
+                    .truncationMode(.tail)
+                if let context = UsageFormatter.modelContextLabel(for: metrics.modelName) {
+                    Text(context)
+                        .font(.caption2)
+                        .foregroundStyle(.secondary)
+                        .lineLimit(1)
+                        .truncationMode(.tail)
+                }
+            }
+            .frame(width: 140, alignment: .leading)
+            Text(UsageFormatter.tokenCountString(Int(metrics.tokensPerRequest)))
+                .font(.caption)
+                .frame(width: 90, alignment: .leading)
+            if let cost = metrics.costPerRequest {
+                Text(UsageFormatter.usdString(cost))
+                    .font(.caption)
+                    .frame(width: 80, alignment: .leading)
+            } else {
+                Text("—")
+                    .font(.caption)
+                    .foregroundStyle(.secondary)
+                    .frame(width: 80, alignment: .leading)
+            }
+            Text(String(format: "%.1f%%", metrics.cacheHitRate * 100))
+                .font(.caption)
+                .foregroundStyle(self.cacheHitColor)
+                .frame(width: 80, alignment: .leading)
+        }
+        .padding(.horizontal, RunicSpacing.xs)
+        .padding(.vertical, RunicSpacing.compact)
+        .background {
+            if self.isHovered {
+                RoundedRectangle(cornerRadius: RunicSpacing.xxs, style: .continuous)
+                    .fill(Color(nsColor: .separatorColor).opacity(0.15))
+            }
+        }
+    }
+
+    private var cacheHitColor: Color {
+        if metrics.cacheHitRate > 0.5 {
+            return Color(red: 0.46, green: 0.75, blue: 0.36)
+        } else if metrics.cacheHitRate > 0.2 {
+            return Color(red: 0.94, green: 0.74, blue: 0.26)
+        } else {
+            return .secondary
+        }
+    }
+}

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

@@ -0,0 +1,228 @@
+import AppKit
+import Charts
+import RunicCore
+import SwiftUI
+
+// MARK: - Hero Today Stat (Feature 4)
+
+/// Large bold today usage stat with provider icon — inspired by Tokex "2h 21m Today usage".
+@MainActor
+struct HeroTodayStatView: View {
+    let providerIcon: NSImage?
+    let tokenCount: Int
+    let costUSD: Double?
+    let width: CGFloat
+    @Environment(\.menuItemHighlighted) private var isHighlighted
+
+    var body: some View {
+        HStack(alignment: .center, spacing: RunicSpacing.xs) {
+            if let icon = self.providerIcon {
+                Image(nsImage: icon)
+                    .resizable()
+                    .aspectRatio(contentMode: .fit)
+                    .frame(width: 28, height: 28)
+                    .shadow(color: .black.opacity(0.15), radius: 2, y: 1)
+            }
+            VStack(alignment: .leading, spacing: 0) {
+                HStack(alignment: .firstTextBaseline, spacing: RunicSpacing.xxs) {
+                    Text(UsageFormatter.tokenCountString(self.tokenCount))
+                        .font(.system(size: 26, weight: .bold, design: .rounded))
+                        .foregroundStyle(MenuHighlightStyle.primary(self.isHighlighted))
+                    Text("today")
+                        .font(.system(.subheadline, design: .rounded))
+                        .foregroundStyle(MenuHighlightStyle.secondary(self.isHighlighted))
+                }
+            }
+            Spacer()
+            if let cost = self.costUSD, cost > 0 {
+                Text(UsageFormatter.usdString(cost))
+                    .font(.system(.subheadline, design: .rounded))
+                    .fontWeight(.medium)
+                    .foregroundStyle(MenuHighlightStyle.secondary(self.isHighlighted))
+                    .padding(.horizontal, RunicSpacing.xs)
+                    .padding(.vertical, RunicSpacing.xxxs)
+                    .background(
+                        Capsule(style: .continuous)
+                            .fill(Color(nsColor: .controlBackgroundColor).opacity(RunicColors.Opacity.light))
+                    )
+            }
+        }
+        .padding(.horizontal, MenuCardMetrics.horizontalPadding)
+        .padding(.vertical, RunicSpacing.xxs)
+        .frame(minWidth: self.width, maxWidth: .infinity, alignment: .leading)
+        .accessibilityElement(children: .ignore)
+        .accessibilityLabel("Today usage: \(UsageFormatter.tokenCountString(self.tokenCount)) tokens\(self.costUSD.map { ", \(UsageFormatter.usdString($0))" } ?? "")")
+    }
+}
+
+// MARK: - Glassmorphism Stat Cards (Feature 2)
+
+/// Two side-by-side frosted glass cards: Peak Hour + This Week — inspired by Tokex.
+@MainActor
+struct GlassmorphismStatCardsView: View {
+    let peakHourLabel: String
+    let peakHourTokens: String
+    let hourlySparkline: [Int]
+    let weekTotalTokens: String
+    let dailySparkline: [Int]
+    let width: CGFloat
+    @Environment(\.menuItemHighlighted) private var isHighlighted
+
+    var body: some View {
+        HStack(spacing: RunicSpacing.xs) {
+            GlassStatCard(
+                title: "Peak Hour",
+                value: self.peakHourLabel,
+                detail: self.peakHourTokens,
+                sparkline: self.hourlySparkline,
+                sparkColor: RunicColors.chartColor(at: 0),
+                isHighlighted: self.isHighlighted)
+            GlassStatCard(
+                title: "This Week",
+                value: self.weekTotalTokens,
+                detail: nil,
+                sparkline: self.dailySparkline,
+                sparkColor: Color(nsColor: .systemGray),
+                isHighlighted: self.isHighlighted)
+        }
+        .padding(.horizontal, MenuCardMetrics.horizontalPadding)
+        .padding(.vertical, RunicSpacing.xxs)
+        .frame(minWidth: self.width, maxWidth: .infinity, alignment: .leading)
+        .accessibilityElement(children: .ignore)
+        .accessibilityLabel("Peak hour \(self.peakHourLabel), \(self.peakHourTokens). This week \(self.weekTotalTokens)")
+    }
+}
+
+private struct GlassStatCard: View {
+    let title: String
+    let value: String
+    let detail: String?
+    let sparkline: [Int]
+    let sparkColor: Color
+    let isHighlighted: Bool
+
+    var body: some View {
+        VStack(alignment: .leading, spacing: RunicSpacing.xxs) {
+            Text(self.title)
+                .font(.system(.caption2, design: .rounded))
+                .fontWeight(.medium)
+                .foregroundStyle(MenuHighlightStyle.secondary(self.isHighlighted))
+            MiniSparklineView(data: self.sparkline, color: self.sparkColor)
+                .frame(height: 24)
+            Text(self.value)
+                .font(.system(.title3, design: .rounded))
+                .fontWeight(.bold)
+                .foregroundStyle(MenuHighlightStyle.primary(self.isHighlighted))
+            if let detail {
+                Text(detail)
+                    .font(.system(.caption2, design: .rounded))
+                    .foregroundStyle(MenuHighlightStyle.secondary(self.isHighlighted))
+            }
+        }
+        .padding(RunicSpacing.sm)
+        .frame(maxWidth: .infinity, alignment: .leading)
+        .background(
+            RoundedRectangle(cornerRadius: RunicCornerRadius.lg, style: .continuous)
+                .fill(.ultraThinMaterial)
+        )
+        .overlay(
+            RoundedRectangle(cornerRadius: RunicCornerRadius.lg, style: .continuous)
+                .stroke(Color(nsColor: .separatorColor).opacity(RunicColors.Opacity.medium), lineWidth: 0.5)
+        )
+        .shadow(color: .black.opacity(0.08), radius: 4, y: 2)
+        .glassShimmer()
+    }
+}
+
+/// Lightweight sparkline with gradient fill — no Swift Charts overhead.
+private struct MiniSparklineView: View {
+    let data: [Int]
+    let color: Color
+
+    var body: some View {
+        GeometryReader { geo in
+            let maxVal = self.data.max() ?? 0
+            if self.data.count >= 2, maxVal > 0 {
+                let points = self.normalizedPoints(size: geo.size, max: maxVal)
+                // Filled gradient area under the line
+                Path { path in
+                    path.move(to: CGPoint(x: points[0].x, y: geo.size.height))
+                    for point in points { path.addLine(to: point) }
+                    path.addLine(to: CGPoint(x: points.last!.x, y: geo.size.height))
+                    path.closeSubpath()
+                }
+                .fill(
+                    LinearGradient(
+                        colors: [self.color.opacity(0.25), self.color.opacity(0.02)],
+                        startPoint: .top,
+                        endPoint: .bottom))
+                // Line stroke
+                Path { path in
+                    path.move(to: points[0])
+                    for point in points.dropFirst() { path.addLine(to: point) }
+                }
+                .stroke(self.color, style: StrokeStyle(lineWidth: 1.5, lineCap: .round, lineJoin: .round))
+            } else if self.data.count == 1, maxVal > 0 {
+                // Single data point: show a dot
+                Circle()
+                    .fill(self.color)
+                    .frame(width: 4, height: 4)
+                    .position(x: geo.size.width / 2, y: geo.size.height / 2)
+            }
+        }
+    }
+
+    private func normalizedPoints(size: CGSize, max maxVal: Int) -> [CGPoint] {
+        let count = self.data.count
+        guard count >= 2 else { return [] }
+        let step = size.width / CGFloat(count - 1)
+        let yPadding: CGFloat = 3
+        let usableHeight = size.height - yPadding * 2
+        return self.data.enumerated().map { index, value in
+            let x = CGFloat(index) * step
+            let y = yPadding + usableHeight * (1 - CGFloat(value) / CGFloat(maxVal))
+            return CGPoint(x: x, y: y)
+        }
+    }
+}
+
+// MARK: - Updated Ago Timestamp (Feature 7)
+
+/// Shows "Updated X ago" with second-level precision.
+@MainActor
+struct UpdatedTimestampView: View {
+    let updatedAt: Date
+    let width: CGFloat
+    @Environment(\.menuItemHighlighted) private var isHighlighted
+
+    var body: some View {
+        TimelineView(.periodic(from: .now, by: 5)) { context in
+            let text = Self.relativeString(from: self.updatedAt, to: context.date)
+            Text(text)
+                .font(.system(.caption2, design: .rounded))
+                .foregroundStyle(MenuHighlightStyle.secondary(self.isHighlighted).opacity(0.7))
+        }
+        .padding(.horizontal, MenuCardMetrics.horizontalPadding)
+        .padding(.vertical, RunicSpacing.xxxs)
+        .frame(minWidth: self.width, maxWidth: .infinity, alignment: .leading)
+        .accessibilityElement(children: .ignore)
+        .accessibilityLabel(Self.relativeString(from: self.updatedAt, to: Date()))
+    }
+
+    private static func relativeString(from date: Date, to now: Date) -> String {
+        let seconds = Int(now.timeIntervalSince(date))
+        if seconds < 5 { return "Updated just now" }
+        if seconds < 60 { return "Updated \(seconds)s ago" }
+        let minutes = seconds / 60
+        let remainingSeconds = seconds % 60
+        if minutes < 60 {
+            if remainingSeconds > 0 {
+                return "Updated \(minutes)m \(remainingSeconds)s ago"
+            }
+            return "Updated \(minutes)m ago"
+        }
+        let hours = minutes / 60
+        let remainingMinutes = minutes % 60
+        return "Updated \(hours)h \(remainingMinutes)m ago"
+    }
+}