@sriinnu/runic 1.2.0 → 2.11.1

package/RuniciOS/Core/iOSUsageStore.swift

@@ -1,192 +0,0 @@
-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

@@ -1,312 +0,0 @@
-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())
-}