@sriinnu/runic 2.0.0 → 2.11.2

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

@@ -1,214 +0,0 @@
-import Charts
-import RunicCore
-import SwiftUI
-
-/// Subscription utilization chart — shows daily usage as % bars with Daily/Weekly/Monthly picker.
-/// Inspired by CodexBar "Subscription Utilization" submenu.
-@MainActor
-struct SubscriptionUtilizationChartMenuView: View {
-    enum Period: String, CaseIterable {
-        case daily = "Daily"
-        case weekly = "Weekly"
-        case monthly = "Monthly"
-    }
-
-    private struct UtilizationBar: Identifiable {
-        let id: String
-        let label: String
-        let date: Date
-        let usedPercent: Double
-        let isToday: Bool
-    }
-
-    private let dailySummaries: [UsageLedgerDailySummary]
-    private let currentUsedPercent: Double
-    private let todayTokens: Int
-    private let width: CGFloat
-    @State private var selectedPeriod: Period = .daily
-
-    init(
-        dailySummaries: [UsageLedgerDailySummary],
-        currentUsedPercent: Double,
-        todayTokens: Int,
-        width: CGFloat)
-    {
-        self.dailySummaries = dailySummaries
-        self.currentUsedPercent = currentUsedPercent
-        self.todayTokens = todayTokens
-        self.width = width
-    }
-
-    private static let barColor = RunicColors.chartColor(at: 4) // teal
-    private static let wastedColor = Color(nsColor: .systemGray).opacity(0.2)
-
-    var body: some View {
-        let model = Self.makeModel(
-            from: self.dailySummaries,
-            period: self.selectedPeriod,
-            currentUsedPercent: self.currentUsedPercent,
-            todayTokens: self.todayTokens)
-
-        VStack(alignment: .leading, spacing: RunicSpacing.xs) {
-            Text("Utilization")
-                .font(RunicFont.subheadline)
-                .fontWeight(.semibold)
-
-            Picker("", selection: self.$selectedPeriod) {
-                ForEach(Period.allCases, id: \.self) { period in
-                    Text(period.rawValue).tag(period)
-                }
-            }
-            .pickerStyle(.segmented)
-
-            if model.bars.isEmpty {
-                Text("No utilization data available.")
-                    .font(RunicFont.footnote)
-                    .foregroundStyle(.secondary)
-                    .frame(height: 80)
-            } else {
-                Chart {
-                    ForEach(model.bars) { bar in
-                        BarMark(
-                            x: .value("Period", bar.label),
-                            y: .value("Used %", bar.usedPercent))
-                            .foregroundStyle(bar.isToday ? Self.barColor : Self.barColor.opacity(0.6))
-                            .cornerRadius(RunicCornerRadius.xs)
-                    }
-                }
-                .chartYScale(domain: 0...100)
-                .chartYAxis {
-                    AxisMarks(values: [0, 25, 50, 75, 100]) { value in
-                        AxisGridLine(stroke: StrokeStyle(lineWidth: 0.5, dash: [4, 3]))
-                            .foregroundStyle(Color(nsColor: .separatorColor).opacity(0.5))
-                        AxisValueLabel {
-                            if let pct = value.as(Int.self) {
-                                Text("\(pct)%")
-                                    .font(RunicFont.caption2)
-                                    .foregroundStyle(Color(nsColor: .tertiaryLabelColor))
-                            }
-                        }
-                    }
-                }
-                .chartXAxis {
-                    AxisMarks(values: .automatic(desiredCount: 5)) { _ in
-                        AxisValueLabel()
-                            .font(RunicFont.caption2)
-                            .foregroundStyle(Color(nsColor: .tertiaryLabelColor))
-                    }
-                }
-                .chartLegend(.hidden)
-                .frame(height: RunicSpacing.chartHeight - 10)
-
-                // Latest detail
-                if let latest = model.bars.last {
-                    let used = Int(latest.usedPercent.rounded())
-                    let unused = max(0, 100 - used)
-                    Text("\(latest.label): \(used)% used, \(unused)% unused")
-                        .font(RunicFont.caption)
-                        .foregroundStyle(.secondary)
-                }
-            }
-        }
-        .chartPanelStyle(width: self.width)
-        .accessibilityElement(children: .ignore)
-        .accessibilityLabel("Subscription utilization chart")
-    }
-
-    // MARK: - Model
-
-    private struct UtilizationModel {
-        let bars: [UtilizationBar]
-    }
-
-    private static func makeModel(
-        from summaries: [UsageLedgerDailySummary],
-        period: Period,
-        currentUsedPercent: Double,
-        todayTokens: Int) -> UtilizationModel
-    {
-        let calendar = Calendar.current
-        let todayStart = calendar.startOfDay(for: Date())
-
-        // Build token counts by day
-        var tokensByDay: [String: Int] = [:]
-        let formatter = DateFormatter()
-        formatter.dateFormat = "yyyy-MM-dd"
-        formatter.timeZone = TimeZone.current
-
-        for summary in summaries {
-            tokensByDay[summary.dayKey, default: 0] += summary.totals.totalTokens
-        }
-
-        // Scale factor: map today's tokens to the current used %
-        let scaleFactor: Double = todayTokens > 0 ? currentUsedPercent / Double(todayTokens) : 0
-
-        switch period {
-        case .daily:
-            let bars = (0..<14).compactMap { offset -> UtilizationBar? in
-                guard let date = calendar.date(byAdding: .day, value: offset - 13, to: todayStart) else { return nil }
-                let key = formatter.string(from: date)
-                let tokens = tokensByDay[key] ?? 0
-                let pct = min(100, Double(tokens) * scaleFactor)
-                let label = date.formatted(.dateTime.day().month(.abbreviated))
-                let isToday = offset == 13
-                return UtilizationBar(id: key, label: label, date: date, usedPercent: pct, isToday: isToday)
-            }
-            return UtilizationModel(bars: bars)
-
-        case .weekly:
-            // Aggregate by ISO week
-            var weekBuckets: [(label: String, tokens: Int, date: Date, isThisWeek: Bool)] = []
-            for weekOffset in stride(from: -3, through: 0, by: 1) {
-                guard let weekStart = calendar.date(byAdding: .weekOfYear, value: weekOffset, to: todayStart)
-                else { continue }
-                var total = 0
-                for dayOffset in 0..<7 {
-                    guard let date = calendar.date(byAdding: .day, value: dayOffset, to: weekStart) else { continue }
-                    total += tokensByDay[formatter.string(from: date)] ?? 0
-                }
-                let label = "W\(calendar.component(.weekOfYear, from: weekStart))"
-                weekBuckets.append((label, total, weekStart, weekOffset == 0))
-            }
-            let maxWeekTokens = weekBuckets.map(\.tokens).max() ?? 1
-            let bars = weekBuckets.map { bucket in
-                let pct = maxWeekTokens > 0 ? Double(bucket.tokens) / Double(maxWeekTokens) * 100 : 0
-                return UtilizationBar(
-                    id: bucket.label,
-                    label: bucket.label,
-                    date: bucket.date,
-                    usedPercent: pct,
-                    isToday: bucket.isThisWeek)
-            }
-            return UtilizationModel(bars: bars)
-
-        case .monthly:
-            var monthBuckets: [(label: String, tokens: Int, date: Date, isThisMonth: Bool)] = []
-            for monthOffset in stride(from: -2, through: 0, by: 1) {
-                guard let monthStart = calendar.date(byAdding: .month, value: monthOffset, to: todayStart)
-                else { continue }
-                let monthComponents = calendar.dateComponents([.year, .month], from: monthStart)
-                guard let actualMonthStart = calendar.date(from: monthComponents),
-                      let range = calendar.range(of: .day, in: .month, for: actualMonthStart) else { continue }
-                var total = 0
-                for dayOffset in 0..<range.count {
-                    guard let date = calendar.date(byAdding: .day, value: dayOffset, to: actualMonthStart)
-                    else { continue }
-                    total += tokensByDay[formatter.string(from: date)] ?? 0
-                }
-                let label = monthStart.formatted(.dateTime.month(.abbreviated))
-                monthBuckets.append((label, total, monthStart, monthOffset == 0))
-            }
-            let maxMonthTokens = monthBuckets.map(\.tokens).max() ?? 1
-            let bars = monthBuckets.map { bucket in
-                let pct = maxMonthTokens > 0 ? Double(bucket.tokens) / Double(maxMonthTokens) * 100 : 0
-                return UtilizationBar(
-                    id: bucket.label,
-                    label: bucket.label,
-                    date: bucket.date,
-                    usedPercent: pct,
-                    isToday: bucket.isThisMonth)
-            }
-            return UtilizationModel(bars: bars)
-        }
-    }
-}

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

@@ -1,398 +0,0 @@
-import Charts
-import RunicCore
-import SwiftUI
-
-@MainActor
-struct UsageBreakdownChartMenuView: View {
-    private struct Point: Identifiable {
-        let id: String
-        let date: Date
-        let service: String
-        let creditsUsed: Double
-
-        init(date: Date, service: String, creditsUsed: Double) {
-            self.date = date
-            self.service = service
-            self.creditsUsed = creditsUsed
-            self.id = "\(service)-\(Int(date.timeIntervalSince1970))- \(creditsUsed)"
-        }
-    }
-
-    private let breakdown: [OpenAIDashboardDailyBreakdown]
-    private let width: CGFloat
-    @State private var selectedDayKey: String?
-
-    init(breakdown: [OpenAIDashboardDailyBreakdown], 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.points.isEmpty {
-                Text("No usage breakdown data.")
-                    .font(RunicFont.footnote)
-                    .foregroundStyle(.secondary)
-            } else {
-                Chart {
-                    ForEach(model.points) { point in
-                        BarMark(
-                            x: .value("Day", point.date, unit: .day),
-                            y: .value("Credits used", point.creditsUsed))
-                            .foregroundStyle(by: .value("Service", point.service))
-                    }
-                    if let peak = model.peakPoint {
-                        let capStart = max(peak.creditsUsed - Self.capHeight(maxValue: model.maxCreditsUsed), 0)
-                        BarMark(
-                            x: .value("Day", peak.date, unit: .day),
-                            yStart: .value("Cap start", capStart),
-                            yEnd: .value("Cap end", peak.creditsUsed))
-                            .foregroundStyle(Color(nsColor: .systemYellow))
-                    }
-                }
-                .chartForegroundStyleScale(domain: model.services, range: model.serviceColors)
-                .chartYAxis(.hidden)
-                .chartXAxis {
-                    AxisMarks(values: model.axisDates) { _ in
-                        AxisGridLine().foregroundStyle(Color.clear)
-                        AxisTick().foregroundStyle(Color.clear)
-                        AxisValueLabel(format: .dateTime.month(.abbreviated).day())
-                            .font(RunicFont.caption2)
-                            .foregroundStyle(Color(nsColor: .tertiaryLabelColor))
-                    }
-                }
-                .chartLegend(.hidden)
-                .frame(height: RunicSpacing.chartHeight)
-                .accessibilityElement(children: .ignore)
-                .accessibilityLabel(self.chartAccessibilityLabel(model: model))
-                .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())
-                        }
-                    }
-                }
-
-                let detail = self.detailLines(model: model)
-                VStack(alignment: .leading, spacing: 0) {
-                    Text(detail.primary)
-                        .font(RunicFont.caption)
-                        .foregroundStyle(.secondary)
-                        .lineLimit(1)
-                        .truncationMode(.tail)
-                        .frame(height: 16, alignment: .leading)
-                    Text(detail.secondary ?? " ")
-                        .font(RunicFont.caption)
-                        .foregroundStyle(.secondary)
-                        .lineLimit(1)
-                        .truncationMode(.tail)
-                        .frame(height: 16, alignment: .leading)
-                        .opacity(detail.secondary == nil ? 0 : 1)
-                }
-
-                LazyVGrid(
-                    columns: [GridItem(.adaptive(minimum: 110), alignment: .leading)],
-                    alignment: .leading,
-                    spacing: RunicSpacing.compact)
-                {
-                    ForEach(model.services, id: \.self) { service in
-                        HStack(spacing: RunicSpacing.compact) {
-                            Circle()
-                                .fill(model.color(for: service))
-                                .frame(width: RunicSpacing.chartLegendDot, height: RunicSpacing.chartLegendDot)
-                            Text(service)
-                                .font(RunicFont.caption2)
-                                .foregroundStyle(.secondary)
-                                .lineLimit(1)
-                        }
-                    }
-                }
-            }
-        }
-        .padding(.horizontal, MenuCardMetrics.horizontalPadding)
-        .padding(.vertical, RunicSpacing.xs)
-        .frame(minWidth: self.width, maxWidth: .infinity, alignment: .leading)
-    }
-
-    private struct Model {
-        let points: [Point]
-        let breakdownByDayKey: [String: OpenAIDashboardDailyBreakdown]
-        let dayDates: [(dayKey: String, date: Date)]
-        let peakPoint: (date: Date, creditsUsed: Double)?
-        let services: [String]
-        let serviceColors: [Color]
-        let axisDates: [Date]
-        let maxCreditsUsed: Double
-
-        func color(for service: String) -> Color {
-            guard let idx = self.services.firstIndex(of: service), idx < self.serviceColors.count else {
-                return .secondary
-            }
-            return self.serviceColors[idx]
-        }
-    }
-
-    private static let selectionBandColor = Color(nsColor: .labelColor).opacity(0.1)
-
-    private static func makeModel(from breakdown: [OpenAIDashboardDailyBreakdown]) -> Model {
-        let sorted = breakdown
-            .sorted { lhs, rhs in lhs.day < rhs.day }
-
-        var points: [Point] = []
-        points.reserveCapacity(sorted.count * 2)
-
-        var breakdownByDayKey: [String: OpenAIDashboardDailyBreakdown] = [:]
-        breakdownByDayKey.reserveCapacity(sorted.count)
-
-        var dayDates: [(dayKey: String, date: Date)] = []
-        dayDates.reserveCapacity(sorted.count)
-
-        var peak: (date: Date, creditsUsed: Double)?
-        var maxCreditsUsed: Double = 0
-
-        for day in sorted {
-            guard let date = self.dateFromDayKey(day.day) else { continue }
-            breakdownByDayKey[day.day] = day
-            dayDates.append((dayKey: day.day, date: date))
-            if day.totalCreditsUsed > 0 {
-                if let cur = peak {
-                    if day.totalCreditsUsed > cur.creditsUsed { peak = (date, day.totalCreditsUsed) }
-                } else {
-                    peak = (date, day.totalCreditsUsed)
-                }
-                maxCreditsUsed = max(maxCreditsUsed, day.totalCreditsUsed)
-            }
-            for service in day.services where service.creditsUsed > 0 {
-                points.append(Point(date: date, service: service.service, creditsUsed: service.creditsUsed))
-            }
-        }
-
-        let services = Self.serviceOrder(from: sorted)
-        let colors = services.map { Self.colorForService($0) }
-        let axisDates = Self.axisDates(fromSortedDays: sorted)
-
-        return Model(
-            points: points,
-            breakdownByDayKey: breakdownByDayKey,
-            dayDates: dayDates,
-            peakPoint: peak,
-            services: services,
-            serviceColors: colors,
-            axisDates: axisDates,
-            maxCreditsUsed: maxCreditsUsed)
-    }
-
-    private static func capHeight(maxValue: Double) -> Double {
-        maxValue * 0.05
-    }
-
-    private static func serviceOrder(from breakdown: [OpenAIDashboardDailyBreakdown]) -> [String] {
-        var totals: [String: Double] = [:]
-        for day in breakdown {
-            for service in day.services {
-                totals[service.service, default: 0] += service.creditsUsed
-            }
-        }
-
-        return totals
-            .sorted { lhs, rhs in
-                if lhs.value == rhs.value { return lhs.key < rhs.key }
-                return lhs.value > rhs.value
-            }
-            .map(\.key)
-    }
-
-    private static func colorForService(_ service: String) -> Color {
-        let lower = service.lowercased()
-        if lower == "cli" {
-            return RunicColors.chartPalette[0]
-        }
-        if lower.contains("github"), lower.contains("review") {
-            return RunicColors.chartPalette[1]
-        }
-        let idx = abs(service.hashValue) % RunicColors.chartPalette.count
-        return RunicColors.chartPalette[idx]
-    }
-
-    private static func axisDates(fromSortedDays sortedDays: [OpenAIDashboardDailyBreakdown]) -> [Date] {
-        guard let first = sortedDays.first, let last = sortedDays.last else { return [] }
-        guard let firstDate = self.dateFromDayKey(first.day),
-              let lastDate = self.dateFromDayKey(last.day)
-        else {
-            return []
-        }
-        if Calendar.current.isDate(firstDate, inSameDayAs: lastDate) {
-            return [firstDate]
-        }
-        return [firstDate, lastDate]
-    }
-
-    private static func dateFromDayKey(_ key: String) -> Date? {
-        let parts = key.split(separator: "-")
-        guard parts.count == 3,
-              let year = Int(parts[0]),
-              let month = Int(parts[1]),
-              let day = Int(parts[2])
-        else {
-            return nil
-        }
-
-        var comps = DateComponents()
-        comps.calendar = Calendar.current
-        comps.timeZone = TimeZone.current
-        comps.year = year
-        comps.month = month
-        comps.day = day
-        // Noon avoids off-by-one-day shifts if anything ends up interpreted in UTC.
-        comps.hour = 12
-        return comps.date
-    }
-
-    private func selectionBandRect(model: Model, proxy: ChartProxy, geo: GeometryProxy) -> CGRect? {
-        guard let key = self.selectedDayKey else { return nil }
-        guard let plotAnchor = proxy.plotFrame else { return nil }
-        let plotFrame = geo[plotAnchor]
-        guard let index = model.dayDates.firstIndex(where: { $0.dayKey == key }) else { return nil }
-        let date = model.dayDates[index].date
-        guard let x = proxy.position(forX: date) else { return nil }
-
-        func xForIndex(_ idx: Int) -> CGFloat? {
-            guard idx >= 0, idx < model.dayDates.count else { return nil }
-            return proxy.position(forX: model.dayDates[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.selectedDayKey != nil { self.selectedDayKey = 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 }
-        guard let nearest = self.nearestDayKey(to: date, model: model) else { return }
-
-        if self.selectedDayKey != nearest {
-            self.selectedDayKey = nearest
-        }
-    }
-
-    private func nearestDayKey(to date: Date, model: Model) -> String? {
-        guard !model.dayDates.isEmpty else { return nil }
-        var best: (key: String, distance: TimeInterval)?
-        for entry in model.dayDates {
-            let dist = abs(entry.date.timeIntervalSince(date))
-            if let cur = best {
-                if dist < cur.distance { best = (entry.dayKey, dist) }
-            } else {
-                best = (entry.dayKey, dist)
-            }
-        }
-        return best?.key
-    }
-
-    private func detailLines(model: Model) -> (primary: String, secondary: String?) {
-        guard let key = self.selectedDayKey,
-              let day = model.breakdownByDayKey[key],
-              let date = Self.dateFromDayKey(key)
-        else {
-            return ("Hover a bar for details", nil)
-        }
-
-        let dayLabel = date.formatted(.dateTime.month(.abbreviated).day())
-        let total = day.totalCreditsUsed.formatted(.number.precision(.fractionLength(0...2)))
-        if day.services.isEmpty {
-            return ("\(dayLabel): \(total)", nil)
-        }
-        if day.services.count <= 1, let first = day.services.first {
-            let used = first.creditsUsed.formatted(.number.precision(.fractionLength(0...2)))
-            return ("\(dayLabel): \(used)", first.service)
-        }
-
-        let services = day.services
-            .sorted { lhs, rhs in
-                if lhs.creditsUsed == rhs.creditsUsed { return lhs.service < rhs.service }
-                return lhs.creditsUsed > rhs.creditsUsed
-            }
-            .prefix(3)
-            .map { "\($0.service) \($0.creditsUsed.formatted(.number.precision(.fractionLength(0...2))))" }
-            .joined(separator: " · ")
-
-        return ("\(dayLabel): \(total)", services)
-    }
-
-    private func chartAccessibilityLabel(model: Model) -> String {
-        guard !model.points.isEmpty else { return "Usage breakdown chart, no data" }
-
-        let dayCount = model.dayDates.count
-
-        // Compute per-service totals
-        var serviceTotals: [String: Double] = [:]
-        for point in model.points {
-            serviceTotals[point.service, default: 0] += point.creditsUsed
-        }
-        let grandTotal = serviceTotals.values.reduce(0, +)
-
-        // Build percentage parts sorted by usage descending
-        let parts: [String] = serviceTotals
-            .sorted { lhs, rhs in
-                if lhs.value == rhs.value { return lhs.key < rhs.key }
-                return lhs.value > rhs.value
-            }
-            .prefix(5)
-            .map { service, total in
-                let pct = grandTotal > 0 ? (total / grandTotal) * 100 : 0
-                return "\(service) \(String(format: "%.0f", pct))%"
-            }
-
-        var label = "Usage breakdown: \(dayCount) day\(dayCount == 1 ? "" : "s")"
-        if !parts.isEmpty {
-            label += ", \(parts.joined(separator: ", "))"
-        }
-        return label
-    }
-}