@sriinnu/runic 1.0.0

package/RuniciOS/Core/iOSUsageStore.swift

@@ -0,0 +1,192 @@
+import Foundation
+import SwiftUI
+import RunicCore
+
+/// iOS-specific usage store with background refresh and notifications
+@MainActor
+@Observable
+final class iOSUsageStore {
+    var snapshots: [UsageProvider: EnhancedUsageSnapshot] = [:]
+    var errors: [UsageProvider: Error] = [:]
+    var isRefreshing = false
+    var lastRefreshDate: Date?
+
+    private let fetcher: UsageFetcher
+    private let notificationManager: NotificationManager
+
+    init() {
+        self.fetcher = UsageFetcher()
+        self.notificationManager = NotificationManager()
+    }
+
+    /// Initial refresh on app launch
+    func initialRefresh() async {
+        await refresh()
+    }
+
+    /// Refresh all enabled providers
+    func refresh() async {
+        isRefreshing = true
+        defer { isRefreshing = false }
+
+        let providers = UsageProvider.allCases.filter { isEnabled($0) }
+
+        await withTaskGroup(of: (UsageProvider, Result<EnhancedUsageSnapshot, Error>).self) { group in
+            for provider in providers {
+                group.addTask {
+                    do {
+                        let snapshot = try await self.fetchSnapshot(for: provider)
+                        return (provider, .success(snapshot))
+                    } catch {
+                        return (provider, .failure(error))
+                    }
+                }
+            }
+
+            for await (provider, result) in group {
+                switch result {
+                case .success(let snapshot):
+                    snapshots[provider] = snapshot
+                    errors[provider] = nil
+
+                    // Check for alerts
+                    await checkAndNotify(snapshot: snapshot)
+
+                case .failure(let error):
+                    errors[provider] = error
+                }
+            }
+        }
+
+        lastRefreshDate = Date()
+    }
+
+    /// Refresh a specific provider
+    func refresh(provider: UsageProvider) async {
+        do {
+            let snapshot = try await fetchSnapshot(for: provider)
+            snapshots[provider] = snapshot
+            errors[provider] = nil
+            await checkAndNotify(snapshot: snapshot)
+        } catch {
+            errors[provider] = error
+        }
+    }
+
+    /// Fetch enhanced snapshot for a provider
+    private func fetchSnapshot(for provider: UsageProvider) async throws -> EnhancedUsageSnapshot {
+        // TODO: Implement actual fetching logic
+        // For now, return mock data
+
+        let usedPercent = Double.random(in: 0...100)
+        let resetAt = Date().addingTimeInterval(Double.random(in: 3600...86400))
+
+        return EnhancedUsageSnapshot(
+            provider: provider,
+            primary: RateWindow(usedPercent: usedPercent, windowMinutes: 300),
+            accountType: .subscription,
+            accountEmail: "user@example.com",
+            primaryReset: UsageResetInfo(
+                resetType: .sessionBased,
+                resetAt: resetAt,
+                windowDuration: 5 * 3600
+            ),
+            primaryModel: ModelUsageInfo(
+                modelName: "claude-3-5-sonnet",
+                modelFamily: .claude3,
+                tier: .sonnet
+            ),
+            updatedAt: Date(),
+            fetchSource: "oauth"
+        )
+    }
+
+    /// Check if usage warrants a notification
+    private func checkAndNotify(snapshot: EnhancedUsageSnapshot) async {
+        // Critical threshold: 90%
+        if snapshot.primary.usedPercent >= 90 {
+            await notificationManager.sendUsageAlert(
+                provider: snapshot.provider,
+                usagePercent: snapshot.primary.usedPercent,
+                severity: .critical
+            )
+        }
+        // Warning threshold: 75%
+        else if snapshot.primary.usedPercent >= 75 {
+            await notificationManager.sendUsageAlert(
+                provider: snapshot.provider,
+                usagePercent: snapshot.primary.usedPercent,
+                severity: .warning
+            )
+        }
+    }
+
+    private func isEnabled(_ provider: UsageProvider) -> Bool {
+        // TODO: Read from UserDefaults
+        return true
+    }
+}
+
+// MARK: - Notification Manager
+
+@MainActor
+final class NotificationManager {
+    func sendUsageAlert(
+        provider: UsageProvider,
+        usagePercent: Double,
+        severity: UsageAlert.Severity
+    ) async {
+        let content = UNMutableNotificationContent()
+        content.title = "\(provider.rawValue.capitalized) Usage Alert"
+
+        switch severity {
+        case .critical:
+            content.body = "⚠️ Critical: \(Int(usagePercent))% used. Approaching limit!"
+            content.sound = .defaultCritical
+        case .warning:
+            content.body = "⚡ Warning: \(Int(usagePercent))% used. Monitor closely."
+            content.sound = .default
+        default:
+            content.body = "\(Int(usagePercent))% used"
+            content.sound = .default
+        }
+
+        content.categoryIdentifier = "USAGE_ALERT"
+        content.userInfo = [
+            "provider": provider.rawValue,
+            "usagePercent": usagePercent
+        ]
+
+        let request = UNNotificationRequest(
+            identifier: UUID().uuidString,
+            content: content,
+            trigger: nil // Immediate
+        )
+
+        do {
+            try await UNUserNotificationCenter.current().add(request)
+        } catch {
+            print("Failed to send notification: \(error)")
+        }
+    }
+}
+
+// MARK: - Alert Manager
+
+@MainActor
+@Observable
+final class AlertManager {
+    var activeAlerts: [UsageAlert] = []
+
+    func addAlert(_ alert: UsageAlert) {
+        activeAlerts.append(alert)
+    }
+
+    func dismissAlert(_ id: String) {
+        activeAlerts.removeAll { $0.id == id }
+    }
+
+    func clearAll() {
+        activeAlerts.removeAll()
+    }
+}

package/RuniciOS/Views/ProviderDetailView.swift

@@ -0,0 +1,312 @@
+import SwiftUI
+import RunicCore
+import Charts
+
+struct ProviderDetailView: View {
+    let snapshot: EnhancedUsageSnapshot
+    @EnvironmentObject var usageStore: iOSUsageStore
+    @State private var selectedTimeRange: TimeRange = .day
+
+    enum TimeRange: String, CaseIterable {
+        case hour = "1H"
+        case day = "24H"
+        case week = "7D"
+        case month = "30D"
+    }
+
+    var body: some View {
+        List {
+            // Header with current status
+            Section {
+                ProviderHeaderView(snapshot: snapshot)
+            }
+            .listRowInsets(EdgeInsets())
+            .listRowBackground(Color.clear)
+
+            // Usage metrics
+            Section("Usage Metrics") {
+                UsageMetricsView(snapshot: snapshot)
+            }
+
+            // Reset information
+            if let resetInfo = snapshot.primaryReset {
+                Section("Reset Information") {
+                    ResetInfoView(resetInfo: resetInfo)
+                }
+            }
+
+            // Model usage
+            if !snapshot.recentModels.isEmpty {
+                Section("Recent Models") {
+                    ForEach(snapshot.recentModels, id: \.modelName) { model in
+                        ModelRowView(model: model)
+                    }
+                }
+            }
+
+            // Token usage
+            if let tokenUsage = snapshot.tokenUsage {
+                Section("Token Usage") {
+                    TokenUsageView(tokenUsage: tokenUsage)
+                }
+            }
+
+            // Project association
+            if let project = snapshot.activeProject {
+                Section("Active Project") {
+                    ProjectInfoView(project: project)
+                }
+            }
+
+            // Historical chart
+            Section {
+                Picker("Time Range", selection: $selectedTimeRange) {
+                    ForEach(TimeRange.allCases, id: \.self) { range in
+                        Text(range.rawValue).tag(range)
+                    }
+                }
+                .pickerStyle(.segmented)
+
+                UsageChartView(
+                    provider: snapshot.provider,
+                    timeRange: selectedTimeRange
+                )
+                .frame(height: 200)
+            } header: {
+                Text("Usage History")
+            }
+
+            // Account info
+            Section("Account") {
+                LabeledContent("Type") {
+                    AccountTypeBadge(type: snapshot.accountType)
+                }
+
+                if let email = snapshot.accountEmail {
+                    LabeledContent("Email", value: email)
+                }
+
+                if let org = snapshot.accountOrganization {
+                    LabeledContent("Organization", value: org)
+                }
+
+                LabeledContent("Data Source", value: snapshot.fetchSource)
+            }
+        }
+        .navigationTitle(snapshot.provider.rawValue.capitalized)
+        .navigationBarTitleDisplayMode(.inline)
+        .toolbar {
+            ToolbarItem(placement: .topBarTrailing) {
+                Button {
+                    Task {
+                        await usageStore.refresh(provider: snapshot.provider)
+                    }
+                } label: {
+                    Image(systemName: "arrow.clockwise")
+                }
+            }
+        }
+    }
+}
+
+// MARK: - Provider Header
+
+struct ProviderHeaderView: View {
+    let snapshot: EnhancedUsageSnapshot
+
+    var statusColor: Color {
+        let usage = snapshot.primary.usedPercent
+        if usage >= 90 { return .red }
+        if usage >= 75 { return .orange }
+        return .green
+    }
+
+    var body: some View {
+        VStack(spacing: 20) {
+            // Large usage indicator
+            ZStack {
+                Circle()
+                    .stroke(.quaternary, lineWidth: 12)
+
+                Circle()
+                    .trim(from: 0, to: snapshot.primary.usedPercent / 100)
+                    .stroke(statusColor.gradient, style: StrokeStyle(lineWidth: 12, lineCap: .round))
+                    .rotationEffect(.degrees(-90))
+
+                VStack(spacing: 4) {
+                    Text("\(Int(snapshot.primary.usedPercent))%")
+                        .font(.system(.largeTitle, design: .rounded, weight: .bold))
+                        .foregroundStyle(statusColor)
+
+                    Text("Used")
+                        .font(.caption)
+                        .foregroundStyle(.secondary)
+                }
+            }
+            .frame(width: 150, height: 150)
+
+            // Status message
+            if snapshot.primary.usedPercent >= 90 {
+                Text("⚠️ Approaching Limit")
+                    .font(.headline)
+                    .foregroundStyle(.red)
+            } else if snapshot.primary.usedPercent >= 75 {
+                Text("⚡ High Usage")
+                    .font(.headline)
+                    .foregroundStyle(.orange)
+            } else {
+                Text("✓ Healthy")
+                    .font(.headline)
+                    .foregroundStyle(.green)
+            }
+        }
+        .frame(maxWidth: .infinity)
+        .padding()
+    }
+}
+
+// MARK: - Usage Metrics
+
+struct UsageMetricsView: View {
+    let snapshot: EnhancedUsageSnapshot
+
+    var body: some View {
+        VStack(spacing: 12) {
+            MetricRow(
+                title: "Primary Usage",
+                value: snapshot.primary.usedPercent,
+                label: snapshot.primary.resetDescription ?? "Session"
+            )
+
+            if let secondary = snapshot.secondary {
+                MetricRow(
+                    title: "Weekly Usage",
+                    value: secondary.usedPercent,
+                    label: secondary.resetDescription ?? "Week"
+                )
+            }
+
+            if let tertiary = snapshot.tertiary {
+                MetricRow(
+                    title: "Opus Usage",
+                    value: tertiary.usedPercent,
+                    label: tertiary.resetDescription ?? "Premium"
+                )
+            }
+        }
+    }
+}
+
+struct MetricRow: View {
+    let title: String
+    let value: Double
+    let label: String
+
+    var color: Color {
+        if value >= 90 { return .red }
+        if value >= 75 { return .orange }
+        return .green
+    }
+
+    var body: some View {
+        VStack(alignment: .leading, spacing: 6) {
+            HStack {
+                Text(title)
+                    .font(.subheadline)
+                Spacer()
+                Text("\(Int(value))%")
+                    .font(.system(.headline, design: .rounded))
+                    .foregroundStyle(color)
+            }
+
+            GeometryReader { geometry in
+                ZStack(alignment: .leading) {
+                    RoundedRectangle(cornerRadius: 4)
+                        .fill(.quaternary)
+
+                    RoundedRectangle(cornerRadius: 4)
+                        .fill(color.gradient)
+                        .frame(width: geometry.size.width * value / 100)
+                }
+            }
+            .frame(height: 8)
+
+            Text(label)
+                .font(.caption)
+                .foregroundStyle(.secondary)
+        }
+    }
+}
+
+// MARK: - Reset Info View
+
+struct ResetInfoView: View {
+    let resetInfo: UsageResetInfo
+
+    var body: some View {
+        VStack(alignment: .leading, spacing: 8) {
+            LabeledContent("Reset Type") {
+                Text(resetInfo.resetType.rawValue.capitalized)
+            }
+
+            if let timeRemaining = resetInfo.timeUntilReset, timeRemaining > 0 {
+                LabeledContent("Resets In") {
+                    Text(resetInfo.resetDescription)
+                        .foregroundStyle(.blue)
+                }
+            }
+
+            if let duration = resetInfo.windowDuration {
+                let hours = Int(duration / 3600)
+                LabeledContent("Window Duration") {
+                    Text("\(hours) hours")
+                }
+            }
+        }
+    }
+}
+
+// MARK: - Account Type Badge
+
+struct AccountTypeBadge: View {
+    let type: AccountType
+
+    var color: Color {
+        switch type {
+        case .subscription: return .purple
+        case .usageBased: return .blue
+        case .freeTier: return .green
+        case .enterprise: return .orange
+        case .unknown: return .gray
+        }
+    }
+
+    var body: some View {
+        Text(type.rawValue.replacingOccurrences(of: "_", with: " ").capitalized)
+            .font(.caption)
+            .padding(.horizontal, 8)
+            .padding(.vertical, 4)
+            .background(color.opacity(0.2))
+            .foregroundStyle(color)
+            .clipShape(Capsule())
+    }
+}
+
+#Preview {
+    NavigationStack {
+        ProviderDetailView(
+            snapshot: EnhancedUsageSnapshot(
+                provider: .claude,
+                primary: RateWindow(usedPercent: 85, windowMinutes: 300),
+                accountType: .subscription,
+                accountEmail: "user@example.com",
+                primaryReset: UsageResetInfo(
+                    resetType: .sessionBased,
+                    resetAt: Date().addingTimeInterval(3600),
+                    windowDuration: 5 * 3600
+                )
+            )
+        )
+    }
+    .environmentObject(iOSUsageStore())
+}