@sriinnu/runic 1.2.0 → 2.11.1

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

@@ -1,232 +0,0 @@
-import Charts
-import RunicCore
-import SwiftUI
-
-@MainActor
-struct UsageHeatmapMenuView: View {
-    fileprivate struct HeatmapCell: Identifiable {
-        let id: String
-        let hourStart: Date
-        let weekday: Int // 0 = Sunday, 6 = Saturday
-        let hour: Int // 0-23
-        let totalTokens: Int
-        let intensity: Double // 0.0-1.0
-
-        init(hourStart: Date, weekday: Int, hour: Int, totalTokens: Int, maxTokens: Int) {
-            self.hourStart = hourStart
-            self.weekday = weekday
-            self.hour = hour
-            self.totalTokens = totalTokens
-            self.intensity = maxTokens > 0 ? Double(totalTokens) / Double(maxTokens) : 0.0
-            self.id = "\(weekday)-\(hour)"
-        }
-
-        var weekdayLabel: String {
-            ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"][self.weekday]
-        }
-
-        var hourLabel: String {
-            if self.hour == 0 { return "12 AM" }
-            if self.hour < 12 { return "\(self.hour) AM" }
-            if self.hour == 12 { return "12 PM" }
-            return "\(self.hour - 12) PM"
-        }
-    }
-
-    private let hourlySummaries: [UsageLedgerHourlySummary]
-    private let width: CGFloat
-    @State private var selectedCellID: String?
-
-    init(hourlySummaries: [UsageLedgerHourlySummary], width: CGFloat) {
-        self.hourlySummaries = hourlySummaries
-        self.width = width
-    }
-
-    var body: some View {
-        let model = Self.makeModel(from: self.hourlySummaries)
-        VStack(alignment: .leading, spacing: RunicSpacing.sm) {
-            Text("Usage Heatmap (24×7)")
-                .font(.headline)
-                .fontWeight(.semibold)
-
-            if model.isEmpty {
-                Text("No heatmap data.")
-                    .font(.footnote)
-                    .foregroundStyle(.secondary)
-            } else {
-                ScrollView(.horizontal, showsIndicators: true) {
-                    VStack(alignment: .leading, spacing: RunicSpacing.xxs) {
-                        // Hour labels
-                        HStack(spacing: 0) {
-                            Text("")
-                                .frame(width: 40, alignment: .leading)
-                            ForEach(0..<24, id: \.self) { hour in
-                                Text(self.hourLabel(hour))
-                                    .font(.caption2)
-                                    .foregroundStyle(.secondary)
-                                    .frame(width: 40, alignment: .center)
-                                    .lineLimit(1)
-                            }
-                        }
-
-                        // Heatmap grid
-                        ForEach(0..<7, id: \.self) { weekday in
-                            HStack(spacing: 2) {
-                                Text(self.weekdayLabel(weekday))
-                                    .font(.caption)
-                                    .foregroundStyle(.secondary)
-                                    .frame(width: 38, alignment: .leading)
-
-                                ForEach(0..<24, id: \.self) { hour in
-                                    let cell = model.first { $0.weekday == weekday && $0.hour == hour }
-                                    HeatmapCellView(
-                                        cell: cell,
-                                        isSelected: self.selectedCellID == cell?.id)
-                                        .onTapGesture {
-                                            self.selectedCellID = cell?.id
-                                        }
-                                        .onHover { hovering in
-                                            if hovering {
-                                                self.selectedCellID = cell?.id
-                                            } else if self.selectedCellID == cell?.id {
-                                                self.selectedCellID = nil
-                                            }
-                                        }
-                                }
-                            }
-                        }
-
-                        // Legend
-                        HStack(spacing: RunicSpacing.xs) {
-                            Text("Low")
-                                .font(.caption2)
-                                .foregroundStyle(.secondary)
-                            HStack(spacing: 2) {
-                                ForEach(0..<5, id: \.self) { level in
-                                    Rectangle()
-                                        .fill(Self.colorForIntensity(Double(level) / 4.0))
-                                        .frame(width: 16, height: 16)
-                                        .cornerRadius(RunicCornerRadius.xs)
-                                }
-                            }
-                            Text("High")
-                                .font(.caption2)
-                                .foregroundStyle(.secondary)
-                        }
-                        .padding(.top, RunicSpacing.xs)
-                    }
-                    .padding(.horizontal, RunicSpacing.xxs)
-                }
-                .frame(height: 280)
-
-                let detail = self.detailText(model: model)
-                Text(detail)
-                    .font(.caption)
-                    .foregroundStyle(.secondary)
-                    .lineLimit(2)
-                    .frame(height: 32, alignment: .leading)
-            }
-        }
-        .padding(.horizontal, MenuCardMetrics.horizontalPadding)
-        .padding(.vertical, RunicSpacing.xs)
-        .frame(minWidth: self.width, maxWidth: .infinity, alignment: .leading)
-    }
-
-    private static func makeModel(from summaries: [UsageLedgerHourlySummary]) -> [HeatmapCell] {
-        let calendar = Calendar.current
-        var buckets: [String: Int] = [:]
-        var maxTokens = 0
-
-        for summary in summaries {
-            let weekday = calendar.component(.weekday, from: summary.hourStart) - 1 // Convert to 0-6
-            let hour = calendar.component(.hour, from: summary.hourStart)
-            let key = "\(weekday)-\(hour)"
-            buckets[key, default: 0] += summary.totals.totalTokens
-            maxTokens = max(maxTokens, buckets[key]!)
-        }
-
-        var cells: [HeatmapCell] = []
-        for weekday in 0..<7 {
-            for hour in 0..<24 {
-                let key = "\(weekday)-\(hour)"
-                let totalTokens = buckets[key] ?? 0
-                // Use a reference date for the hour start (doesn't matter for display)
-                let hourStart = calendar.date(from: DateComponents(hour: hour)) ?? Date()
-                cells.append(HeatmapCell(
-                    hourStart: hourStart,
-                    weekday: weekday,
-                    hour: hour,
-                    totalTokens: totalTokens,
-                    maxTokens: maxTokens))
-            }
-        }
-
-        return cells
-    }
-
-    fileprivate static func colorForIntensity(_ intensity: Double) -> Color {
-        if intensity == 0 {
-            return Color(nsColor: .separatorColor).opacity(0.3)
-        }
-        if intensity < 0.25 {
-            return Color(red: 0.46, green: 0.75, blue: 0.36).opacity(0.3)
-        } else if intensity < 0.5 {
-            return Color(red: 0.46, green: 0.75, blue: 0.36).opacity(0.6)
-        } else if intensity < 0.75 {
-            return Color(red: 0.94, green: 0.74, blue: 0.26).opacity(0.7)
-        } else {
-            return Color(red: 0.94, green: 0.36, blue: 0.36).opacity(0.8)
-        }
-    }
-
-    private func weekdayLabel(_ weekday: Int) -> String {
-        ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"][weekday]
-    }
-
-    private func hourLabel(_ hour: Int) -> String {
-        if hour == 0 { return "12a" }
-        if hour < 12 { return "\(hour)a" }
-        if hour == 12 { return "12p" }
-        return "\(hour - 12)p"
-    }
-
-    private func detailText(model: [HeatmapCell]) -> String {
-        guard let cellID = self.selectedCellID,
-              let cell = model.first(where: { $0.id == cellID })
-        else {
-            return "Hover a cell for details"
-        }
-
-        if cell.totalTokens == 0 {
-            return "\(cell.weekdayLabel) \(cell.hourLabel): No usage"
-        }
-
-        return "\(cell.weekdayLabel) \(cell.hourLabel): \(UsageFormatter.tokenCountString(cell.totalTokens)) tokens"
-    }
-}
-
-private struct HeatmapCellView: View {
-    let cell: UsageHeatmapMenuView.HeatmapCell?
-    let isSelected: Bool
-
-    var body: some View {
-        Group {
-            if let cell {
-                Rectangle()
-                    .fill(UsageHeatmapMenuView.colorForIntensity(cell.intensity))
-                    .overlay {
-                        if self.isSelected {
-                            Rectangle()
-                                .strokeBorder(Color.blue, lineWidth: 2)
-                        }
-                    }
-            } else {
-                Rectangle()
-                    .fill(Color(nsColor: .separatorColor).opacity(0.2))
-            }
-        }
-        .frame(width: 38, height: 30)
-        .cornerRadius(RunicCornerRadius.xs)
-    }
-}
-

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

@@ -1,364 +0,0 @@
-import Charts
-import RunicCore
-import SwiftUI
-
-@MainActor
-struct UsageTimelineChartMenuView: View {
-    enum TimeRange: String, CaseIterable {
-        case threeDays = "3d"
-        case sevenDays = "7d"
-        case thirtyDays = "30d"
-        case quarter = "90d"
-        case year = "1y"
-
-        var cutoffInterval: TimeInterval {
-            switch self {
-            case .threeDays: return -259200
-            case .sevenDays: return -604800
-            case .thirtyDays: return -2592000
-            case .quarter: return -7776000
-            case .year: return -31536000
-            }
-        }
-
-        var usesHourlyData: Bool { false }
-
-        var label: String { self.rawValue }
-    }
-
-    private struct Point: Identifiable {
-        let id: String
-        let date: Date
-        let totalTokens: Int
-        let key: String
-
-        init(date: Date, totalTokens: Int, key: String) {
-            self.date = date
-            self.totalTokens = totalTokens
-            self.key = key
-            self.id = key
-        }
-    }
-
-    private let dailySummaries: [UsageLedgerDailySummary]
-    private let hourlySummaries: [UsageLedgerHourlySummary]
-    private let width: CGFloat
-    @State private var selectedTimeRange: TimeRange = .sevenDays
-    @State private var selectedKey: String?
-
-    init(
-        dailySummaries: [UsageLedgerDailySummary],
-        hourlySummaries: [UsageLedgerHourlySummary] = [],
-        width: CGFloat)
-    {
-        self.dailySummaries = dailySummaries
-        self.hourlySummaries = hourlySummaries
-        self.width = width
-    }
-
-    private static let lineColor = RunicColors.chartColor(at: 0)
-    private static let selectionBandColor = Color(nsColor: .labelColor).opacity(0.1)
-
-    var body: some View {
-        let model = Self.makeDailyModel(from: self.dailySummaries, timeRange: self.selectedTimeRange)
-
-        VStack(alignment: .leading, spacing: RunicSpacing.xs) {
-            // Header on its own line
-            Text("Timeline")
-                .font(.system(.subheadline, design: .rounded))
-                .fontWeight(.semibold)
-
-            // Range picker on its own line
-            Picker("", selection: self.$selectedTimeRange) {
-                ForEach(TimeRange.allCases, id: \.self) { range in
-                    Text(range.label).tag(range)
-                }
-            }
-            .pickerStyle(.segmented)
-
-            if model.points.isEmpty {
-                Text("No data for selected range.")
-                    .font(.system(.footnote, design: .rounded))
-                    .foregroundStyle(.secondary)
-                    .frame(height: 100)
-            } else {
-                // Line chart
-                Chart {
-                    ForEach(model.points) { point in
-                        AreaMark(
-                            x: .value("Time", point.date),
-                            y: .value("Tokens", point.totalTokens))
-                            .foregroundStyle(
-                                LinearGradient(
-                                    colors: [
-                                        Self.lineColor.opacity(0.25),
-                                        Self.lineColor.opacity(0.03),
-                                    ],
-                                    startPoint: .top,
-                                    endPoint: .bottom))
-                            .interpolationMethod(.catmullRom)
-                        LineMark(
-                            x: .value("Time", point.date),
-                            y: .value("Tokens", point.totalTokens))
-                            .foregroundStyle(Self.lineColor)
-                            .lineStyle(StrokeStyle(lineWidth: 2))
-                            .interpolationMethod(.catmullRom)
-                    }
-                    if let peak = model.peakPoint {
-                        PointMark(
-                            x: .value("Time", peak.date),
-                            y: .value("Tokens", peak.totalTokens))
-                            .foregroundStyle(Color(nsColor: .systemYellow))
-                            .symbolSize(60)
-                            .annotation(position: .top, spacing: 4) {
-                                Text("Peak")
-                                    .font(.system(.caption2, design: .rounded))
-                                    .foregroundStyle(Color(nsColor: .systemYellow))
-                            }
-                    }
-                }
-                .chartYAxis {
-                    AxisMarks(position: .trailing) { value in
-                        AxisGridLine(stroke: StrokeStyle(lineWidth: 0.5, dash: [4, 3]))
-                            .foregroundStyle(Color(nsColor: .separatorColor).opacity(0.5))
-                        AxisValueLabel {
-                            if let tokens = value.as(Int.self) {
-                                Text(UsageFormatter.tokenCountString(tokens))
-                                    .font(.system(.caption2, design: .rounded))
-                                    .foregroundStyle(Color(nsColor: .tertiaryLabelColor))
-                            }
-                        }
-                    }
-                }
-                .chartXAxis {
-                    AxisMarks(values: .automatic(desiredCount: model.desiredAxisCount)) { _ in
-                        AxisGridLine(stroke: StrokeStyle(lineWidth: 0.5, dash: [4, 3]))
-                            .foregroundStyle(Color(nsColor: .separatorColor).opacity(0.3))
-                        AxisValueLabel(format: model.xAxisFormat)
-                            .font(.system(.caption2, design: .rounded))
-                            .foregroundStyle(Color(nsColor: .tertiaryLabelColor))
-                    }
-                }
-                .chartLegend(.hidden)
-                .frame(height: RunicSpacing.chartHeight + 30)
-                .chartOverlay { proxy in
-                    GeometryReader { geo in
-                        ZStack(alignment: .topLeading) {
-                            if let rect = self.selectionBandRect(model: model, proxy: proxy, geo: geo) {
-                                Rectangle()
-                                    .fill(Self.selectionBandColor)
-                                    .frame(width: rect.width, height: rect.height)
-                                    .position(x: rect.midX, y: rect.midY)
-                                    .allowsHitTesting(false)
-                            }
-                            MouseLocationReader { location in
-                                self.updateSelection(location: location, model: model, proxy: proxy, geo: geo)
-                            }
-                            .frame(maxWidth: .infinity, maxHeight: .infinity)
-                            .contentShape(Rectangle())
-                        }
-                    }
-                }
-
-                // Detail line
-                let detail = self.detailText(model: model)
-                Text(detail)
-                    .font(.system(.caption, design: .rounded))
-                    .foregroundStyle(.secondary)
-                    .lineLimit(1)
-                    .truncationMode(.tail)
-                    .frame(height: 16, alignment: .leading)
-
-                // Stats row
-                HStack(spacing: RunicSpacing.md) {
-                    StatCell(label: "Total", value: UsageFormatter.tokenCountString(model.totalTokens))
-                    StatCell(
-                        label: self.selectedTimeRange.usesHourlyData ? "Avg/hr" : "Avg/day",
-                        value: UsageFormatter.tokenCountString(model.averagePerPeriod))
-                    StatCell(label: "Peak", value: UsageFormatter.tokenCountString(model.peakTokens))
-                    if let cost = model.totalCostUSD, cost > 0 {
-                        StatCell(label: "Cost", value: UsageFormatter.usdString(cost))
-                    }
-                }
-            }
-        }
-        .chartPanelStyle(width: self.width)
-        .accessibilityElement(children: .ignore)
-        .accessibilityLabel("Usage timeline chart showing \(model.points.count) data points over \(self.selectedTimeRange.label)")
-    }
-
-    // MARK: - Stat cell
-
-    private struct StatCell: View {
-        let label: String
-        let value: String
-
-        var body: some View {
-            VStack(alignment: .leading, spacing: RunicSpacing.xxxs) {
-                Text(self.label)
-                    .font(.system(.caption2, design: .rounded))
-                    .foregroundStyle(.tertiary)
-                Text(self.value)
-                    .font(.system(.caption, design: .rounded))
-                    .fontWeight(.medium)
-            }
-        }
-    }
-
-    // MARK: - Model
-
-    private struct Model {
-        let points: [Point]
-        let pointsByKey: [String: Point]
-        let dateKeys: [(key: String, date: Date)]
-        let peakPoint: Point?
-        let totalTokens: Int
-        let averagePerPeriod: Int
-        let peakTokens: Int
-        let totalCostUSD: Double?
-        let desiredAxisCount: Int
-        let xAxisFormat: Date.FormatStyle
-        let isHourly: Bool
-    }
-
-    // MARK: - Daily model
-
-    private static func makeDailyModel(from summaries: [UsageLedgerDailySummary], timeRange: TimeRange) -> Model {
-        let now = Date()
-        let cutoffDate = now.addingTimeInterval(timeRange.cutoffInterval)
-        let filtered = summaries.filter { $0.dayStart >= cutoffDate }
-        let sorted = filtered.sorted { $0.dayStart < $1.dayStart }
-
-        var points: [Point] = []
-        var pointsByKey: [String: Point] = [:]
-        var dateKeys: [(key: String, date: Date)] = []
-        var peak: Point?
-        var totalTokens = 0
-        var totalCost: Double = 0
-        var hasCost = false
-
-        for summary in sorted {
-            let tokens = summary.totals.totalTokens
-            totalTokens += tokens
-            if let cost = summary.totals.costUSD {
-                totalCost += cost
-                hasCost = true
-            }
-            let point = Point(date: summary.dayStart, totalTokens: tokens, key: summary.dayKey)
-            points.append(point)
-            pointsByKey[summary.dayKey] = point
-            dateKeys.append((summary.dayKey, summary.dayStart))
-
-            if peak == nil || tokens > (peak?.totalTokens ?? 0) {
-                peak = point
-            }
-        }
-
-        let desiredAxisCount: Int = switch timeRange {
-        case .threeDays: 3
-        case .sevenDays: 5
-        case .thirtyDays: 6
-        case .quarter: 6
-        case .year: 6
-        }
-
-        return Model(
-            points: points,
-            pointsByKey: pointsByKey,
-            dateKeys: dateKeys,
-            peakPoint: peak,
-            totalTokens: totalTokens,
-            averagePerPeriod: points.isEmpty ? 0 : totalTokens / max(1, points.count),
-            peakTokens: peak?.totalTokens ?? 0,
-            totalCostUSD: hasCost ? totalCost : nil,
-            desiredAxisCount: desiredAxisCount,
-            xAxisFormat: .dateTime.month(.abbreviated).day(),
-            isHourly: false)
-    }
-
-    // MARK: - Interaction
-
-    private func selectionBandRect(model: Model, proxy: ChartProxy, geo: GeometryProxy) -> CGRect? {
-        guard let key = self.selectedKey else { return nil }
-        guard let plotAnchor = proxy.plotFrame else { return nil }
-        let plotFrame = geo[plotAnchor]
-        guard let index = model.dateKeys.firstIndex(where: { $0.key == key }) else { return nil }
-        let date = model.dateKeys[index].date
-        guard let x = proxy.position(forX: date) else { return nil }
-
-        func xForIndex(_ idx: Int) -> CGFloat? {
-            guard idx >= 0, idx < model.dateKeys.count else { return nil }
-            return proxy.position(forX: model.dateKeys[idx].date)
-        }
-
-        let xPrev = xForIndex(index - 1)
-        let xNext = xForIndex(index + 1)
-
-        let leftInPlot: CGFloat = if let xPrev {
-            (xPrev + x) / 2
-        } else if let xNext {
-            x - (xNext - x) / 2
-        } else {
-            x - 8
-        }
-
-        let rightInPlot: CGFloat = if let xNext {
-            (xNext + x) / 2
-        } else if let xPrev {
-            x + (x - xPrev) / 2
-        } else {
-            x + 8
-        }
-
-        let left = plotFrame.origin.x + min(leftInPlot, rightInPlot)
-        let right = plotFrame.origin.x + max(leftInPlot, rightInPlot)
-        return CGRect(x: left, y: plotFrame.origin.y, width: right - left, height: plotFrame.height)
-    }
-
-    private func updateSelection(
-        location: CGPoint?,
-        model: Model,
-        proxy: ChartProxy,
-        geo: GeometryProxy)
-    {
-        guard let location else {
-            if self.selectedKey != nil { self.selectedKey = nil }
-            return
-        }
-
-        guard let plotAnchor = proxy.plotFrame else { return }
-        let plotFrame = geo[plotAnchor]
-        guard plotFrame.contains(location) else { return }
-
-        let xInPlot = location.x - plotFrame.origin.x
-        guard let date: Date = proxy.value(atX: xInPlot) else { return }
-
-        var bestKey: String?
-        var bestDistance: TimeInterval = .greatestFiniteMagnitude
-        for entry in model.dateKeys {
-            let dist = abs(entry.date.timeIntervalSince(date))
-            if dist < bestDistance {
-                bestDistance = dist
-                bestKey = entry.key
-            }
-        }
-
-        if let bestKey, self.selectedKey != bestKey {
-            self.selectedKey = bestKey
-        }
-    }
-
-    private func detailText(model: Model) -> String {
-        guard let key = self.selectedKey, let point = model.pointsByKey[key] else {
-            return "Hover for details"
-        }
-        let tokens = UsageFormatter.tokenCountString(point.totalTokens)
-        if model.isHourly {
-            let timeLabel = point.date.formatted(.dateTime.hour(.defaultDigits(amPM: .abbreviated)).minute())
-            return "\(timeLabel): \(tokens) tokens"
-        } else {
-            let dayLabel = point.date.formatted(.dateTime.month(.abbreviated).day())
-            return "\(dayLabel): \(tokens) tokens"
-        }
-    }
-}