@sriinnu/runic 2.0.0 → 2.11.2

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

@@ -1,311 +0,0 @@
-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: "Model"
-            case .tokensPerRequest: "Tokens/Req"
-            case .costPerRequest: "Cost/Req"
-            case .cacheHitRate: "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(RunicFont.headline)
-                .fontWeight(.semibold)
-
-            if model.isEmpty {
-                Text("No efficiency metrics available.")
-                    .font(RunicFont.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(RunicFont.caption2)
-                            .foregroundStyle(.secondary)
-                        Text("\(Self.totalRequests(model))")
-                            .font(RunicFont.caption)
-                            .fontWeight(.medium)
-                    }
-                    VStack(alignment: .leading, spacing: RunicSpacing.xxxs) {
-                        Text("Avg Tokens/Req")
-                            .font(RunicFont.caption2)
-                            .foregroundStyle(.secondary)
-                        Text(UsageFormatter.tokenCountString(Self.averageTokensPerRequest(model)))
-                            .font(RunicFont.caption)
-                            .fontWeight(.medium)
-                    }
-                    if Self.hasAnyCost(model) {
-                        VStack(alignment: .leading, spacing: RunicSpacing.xxxs) {
-                            Text("Avg Cost/Req")
-                                .font(RunicFont.caption2)
-                                .foregroundStyle(.secondary)
-                            Text(UsageFormatter.usdString(Self.averageCostPerRequest(model)))
-                                .font(RunicFont.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) }
-        return 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
-        }
-    }
-
-    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(RunicFont.caption)
-                    .foregroundStyle(.secondary)
-                    .fontWeight(.medium)
-                if self.currentSort == self.column {
-                    Image(systemName: self.ascending ? "chevron.up" : "chevron.down")
-                        .font(RunicFont.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(self.metrics.modelName))
-                    .font(RunicFont.caption)
-                    .lineLimit(1)
-                    .truncationMode(.tail)
-                if let context = UsageFormatter.modelContextLabel(for: metrics.modelName) {
-                    Text(context)
-                        .font(RunicFont.caption2)
-                        .foregroundStyle(.secondary)
-                        .lineLimit(1)
-                        .truncationMode(.tail)
-                }
-            }
-            .frame(width: 140, alignment: .leading)
-            Text(UsageFormatter.tokenCountString(Int(self.metrics.tokensPerRequest)))
-                .font(RunicFont.caption)
-                .frame(width: 90, alignment: .leading)
-            if let cost = metrics.costPerRequest {
-                Text(UsageFormatter.usdString(cost))
-                    .font(RunicFont.caption)
-                    .frame(width: 80, alignment: .leading)
-            } else {
-                Text("—")
-                    .font(RunicFont.caption)
-                    .foregroundStyle(.secondary)
-                    .frame(width: 80, alignment: .leading)
-            }
-            Text(String(format: "%.1f%%", self.metrics.cacheHitRate * 100))
-                .font(RunicFont.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 self.metrics.cacheHitRate > 0.5 {
-            Color(red: 0.46, green: 0.75, blue: 0.36)
-        } else if self.metrics.cacheHitRate > 0.2 {
-            Color(red: 0.94, green: 0.74, blue: 0.26)
-        } else {
-            .secondary
-        }
-    }
-}

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

@@ -1,231 +0,0 @@
-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(RunicFont.system(size: 26, weight: .bold))
-                        .foregroundStyle(MenuHighlightStyle.primary(self.isHighlighted))
-                    Text("today")
-                        .font(RunicFont.subheadline)
-                        .foregroundStyle(MenuHighlightStyle.secondary(self.isHighlighted))
-                }
-            }
-            Spacer()
-            if let cost = self.costUSD, cost > 0 {
-                Text(UsageFormatter.usdString(cost))
-                    .font(RunicFont.subheadline)
-                    .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(RunicFont.caption2)
-                .fontWeight(.medium)
-                .foregroundStyle(MenuHighlightStyle.secondary(self.isHighlighted))
-            MiniSparklineView(data: self.sparkline, color: self.sparkColor)
-                .frame(height: 24)
-            Text(self.value)
-                .font(RunicFont.title3)
-                .fontWeight(.bold)
-                .foregroundStyle(MenuHighlightStyle.primary(self.isHighlighted))
-            if let detail {
-                Text(detail)
-                    .font(RunicFont.caption2)
-                    .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(RunicFont.caption2)
-                .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"
-    }
-}