@sriinnu/runic 1.0.0

package/RuniciOS/Widgets/SmallWidget.swift

@@ -0,0 +1,281 @@
+import SwiftUI
+import WidgetKit
+import RunicCore
+
+// MARK: - Small Widget Configuration
+
+/// Small home screen widget showing a single provider
+///
+/// Displays the most critical provider or user-selected provider with:
+/// - Circular progress ring
+/// - Provider name and icon
+/// - Remaining percentage
+/// - Reset countdown
+struct RunicSmallWidget: Widget {
+    let kind: String = "RunicSmallWidget"
+
+    var body: some WidgetConfiguration {
+        StaticConfiguration(
+            kind: kind,
+            provider: RunicTimelineProvider()
+        ) { entry in
+            SmallWidgetView(entry: entry)
+        }
+        .configurationDisplayName("Runic Usage")
+        .description("Monitor AI provider usage at a glance.")
+        .supportedFamilies([.systemSmall])
+    }
+}
+
+// MARK: - Small Widget View
+
+/// View implementation for small widget
+///
+/// Optimized for compact display with focus on the most important provider.
+struct SmallWidgetView: View {
+    let entry: RunicWidgetEntry
+
+    var body: some View {
+        if entry.isPlaceholder {
+            placeholderView
+        } else if let provider = primaryProvider {
+            contentView(for: provider)
+        } else {
+            emptyStateView
+        }
+    }
+
+    // MARK: - Content Views
+
+    /// Main content view for a single provider
+    private func contentView(for provider: WidgetProviderData) -> some View {
+        VStack(spacing: 12) {
+            // Header with provider name
+            HStack {
+                Circle()
+                    .fill(Color(
+                        red: provider.color.red,
+                        green: provider.color.green,
+                        blue: provider.color.blue
+                    ))
+                    .frame(width: 8, height: 8)
+
+                Text(provider.displayName)
+                    .font(.system(size: 13, weight: .semibold))
+                    .foregroundColor(.white)
+
+                Spacer()
+
+                // Status indicator
+                Image(systemName: statusIcon(for: provider))
+                    .font(.system(size: 12))
+                    .foregroundColor(statusColor(for: provider))
+            }
+            .padding(.horizontal, 16)
+            .padding(.top, 16)
+
+            Spacer()
+
+            // Progress ring
+            UsageProgressRing(provider: provider, size: 80)
+
+            Spacer()
+
+            // Reset countdown
+            VStack(spacing: 2) {
+                if let countdown = provider.resetCountdown {
+                    Text("Resets")
+                        .font(.system(size: 10, weight: .medium))
+                        .foregroundColor(.white.opacity(0.6))
+
+                    Text(countdown)
+                        .font(.system(size: 12, weight: .semibold, design: .rounded))
+                        .foregroundColor(.white.opacity(0.9))
+                } else {
+                    Text("Updated")
+                        .font(.system(size: 10, weight: .medium))
+                        .foregroundColor(.white.opacity(0.6))
+
+                    Text(relativeTime(from: provider.updatedAt))
+                        .font(.system(size: 11, weight: .medium))
+                        .foregroundColor(.white.opacity(0.8))
+                }
+            }
+            .padding(.bottom, 12)
+        }
+    }
+
+    /// Placeholder view for loading state
+    private var placeholderView: some View {
+        VStack(spacing: 12) {
+            HStack {
+                Circle()
+                    .fill(Color.white.opacity(0.2))
+                    .frame(width: 8, height: 8)
+
+                RoundedRectangle(cornerRadius: 4)
+                    .fill(Color.white.opacity(0.2))
+                    .frame(width: 60, height: 12)
+
+                Spacer()
+            }
+            .padding(.horizontal, 16)
+            .padding(.top, 16)
+
+            Spacer()
+
+            // Placeholder ring
+            ZStack {
+                Circle()
+                    .stroke(Color.white.opacity(0.1), lineWidth: 8)
+                    .frame(width: 80, height: 80)
+
+                VStack(spacing: 4) {
+                    RoundedRectangle(cornerRadius: 4)
+                        .fill(Color.white.opacity(0.2))
+                        .frame(width: 30, height: 20)
+
+                    RoundedRectangle(cornerRadius: 3)
+                        .fill(Color.white.opacity(0.1))
+                        .frame(width: 24, height: 10)
+                }
+            }
+
+            Spacer()
+
+            VStack(spacing: 2) {
+                RoundedRectangle(cornerRadius: 3)
+                    .fill(Color.white.opacity(0.1))
+                    .frame(width: 40, height: 10)
+
+                RoundedRectangle(cornerRadius: 3)
+                    .fill(Color.white.opacity(0.15))
+                    .frame(width: 50, height: 12)
+            }
+            .padding(.bottom, 12)
+        }
+    }
+
+    /// Empty state when no data available
+    private var emptyStateView: some View {
+        VStack(spacing: 8) {
+            Image(systemName: "exclamationmark.triangle")
+                .font(.system(size: 24))
+                .foregroundColor(.white.opacity(0.5))
+
+            Text("No Data")
+                .font(.system(size: 14, weight: .semibold))
+                .foregroundColor(.white.opacity(0.7))
+
+            Text("Open app to refresh")
+                .font(.system(size: 11))
+                .foregroundColor(.white.opacity(0.5))
+                .multilineTextAlignment(.center)
+        }
+        .padding()
+    }
+
+    // MARK: - Helper Properties
+
+    /// Get the primary provider to display
+    private var primaryProvider: WidgetProviderData? {
+        entry.providers(for: .systemSmall).first
+    }
+
+    // MARK: - Helper Methods
+
+    /// Get status icon for provider severity
+    private func statusIcon(for provider: WidgetProviderData) -> String {
+        switch provider.severity {
+        case .normal:
+            return "checkmark.circle.fill"
+        case .elevated:
+            return "exclamationmark.circle.fill"
+        case .high:
+            return "exclamationmark.triangle.fill"
+        case .critical:
+            return "xmark.octagon.fill"
+        }
+    }
+
+    /// Get status color for provider severity
+    private func statusColor(for provider: WidgetProviderData) -> Color {
+        switch provider.severity {
+        case .normal:
+            return .green
+        case .elevated:
+            return .yellow
+        case .high:
+            return .orange
+        case .critical:
+            return .red
+        }
+    }
+
+    /// Format relative time string
+    private func relativeTime(from date: Date) -> String {
+        let interval = Date().timeIntervalSince(date)
+        let minutes = Int(interval / 60)
+
+        if minutes < 1 {
+            return "just now"
+        } else if minutes < 60 {
+            return "\(minutes)m ago"
+        } else {
+            let hours = minutes / 60
+            return "\(hours)h ago"
+        }
+    }
+}
+
+// MARK: - Preview Provider
+
+struct SmallWidget_Previews: PreviewProvider {
+    static var previews: some View {
+        let normalEntry = RunicWidgetEntry.placeholder()
+
+        let criticalProvider = WidgetSnapshot.ProviderEntry(
+            provider: .claude,
+            updatedAt: Date(),
+            primary: RateWindow(
+                usedPercent: 95.0,
+                windowMinutes: 300,
+                resetsAt: Date().addingTimeInterval(1800),
+                resetDescription: "in 30m"
+            ),
+            secondary: nil,
+            tertiary: nil,
+            creditsRemaining: nil,
+            codeReviewRemainingPercent: nil,
+            tokenUsage: nil,
+            dailyUsage: []
+        )
+
+        let criticalSnapshot = WidgetSnapshot(
+            entries: [criticalProvider],
+            enabledProviders: [.claude],
+            generatedAt: Date()
+        )
+
+        let criticalEntry = RunicWidgetEntry(
+            date: Date(),
+            snapshot: criticalSnapshot,
+            configuration: .default,
+            isPlaceholder: false
+        )
+
+        Group {
+            SmallWidgetView(entry: normalEntry)
+                .previewContext(WidgetPreviewContext(family: .systemSmall))
+                .previewDisplayName("Normal Usage")
+
+            SmallWidgetView(entry: criticalEntry)
+                .previewContext(WidgetPreviewContext(family: .systemSmall))
+                .previewDisplayName("Critical Usage")
+
+            SmallWidgetView(entry: .placeholder())
+                .previewContext(WidgetPreviewContext(family: .systemSmall))
+                .previewDisplayName("Placeholder")
+        }
+    }
+}

package/RuniciOS/Widgets/WidgetModels.swift

@@ -0,0 +1,285 @@
+import Foundation
+import WidgetKit
+import RunicCore
+
+// MARK: - Widget Entry
+
+/// Timeline entry for Runic widgets
+///
+/// Contains the snapshot data needed to render widget UI. Each entry represents
+/// a point in time with provider usage information.
+public struct RunicWidgetEntry: TimelineEntry {
+    /// The date for this timeline entry
+    public let date: Date
+
+    /// Widget snapshot containing usage data for all providers
+    public let snapshot: WidgetSnapshot
+
+    /// Widget configuration determining which providers to display
+    public let configuration: WidgetConfiguration
+
+    /// Whether the data is a placeholder (loading state)
+    public let isPlaceholder: Bool
+
+    public init(
+        date: Date,
+        snapshot: WidgetSnapshot,
+        configuration: WidgetConfiguration,
+        isPlaceholder: Bool = false
+    ) {
+        self.date = date
+        self.snapshot = snapshot
+        self.configuration = configuration
+        self.isPlaceholder = isPlaceholder
+    }
+}
+
+// MARK: - Widget Configuration
+
+/// Configuration for widget display preferences
+///
+/// Controls which providers are shown and how the widget should behave.
+public struct WidgetConfiguration: Codable, Hashable {
+    /// Primary provider to display (for small widgets)
+    public let primaryProvider: UsageProvider?
+
+    /// Additional providers to show (for medium/large widgets)
+    public let additionalProviders: [UsageProvider]
+
+    /// Show only enabled providers
+    public let showEnabledOnly: Bool
+
+    /// Sort providers by usage severity
+    public let sortBySeverity: Bool
+
+    public init(
+        primaryProvider: UsageProvider? = nil,
+        additionalProviders: [UsageProvider] = [],
+        showEnabledOnly: Bool = true,
+        sortBySeverity: Bool = true
+    ) {
+        self.primaryProvider = primaryProvider
+        self.additionalProviders = additionalProviders
+        self.showEnabledOnly = showEnabledOnly
+        self.sortBySeverity = sortBySeverity
+    }
+
+    /// Default configuration showing enabled providers
+    public static var `default`: WidgetConfiguration {
+        WidgetConfiguration()
+    }
+}
+
+// MARK: - Widget Display Data
+
+/// Processed provider data ready for widget display
+///
+/// Simplifies the provider entry data into a form optimized for widget rendering.
+public struct WidgetProviderData: Identifiable, Hashable {
+    public let id: UsageProvider
+    public let displayName: String
+    public let usedPercent: Double
+    public let remainingPercent: Double
+    public let resetCountdown: String?
+    public let severity: UsageSeverity
+    public let color: ProviderColorData
+    public let updatedAt: Date
+
+    public init(
+        id: UsageProvider,
+        displayName: String,
+        usedPercent: Double,
+        remainingPercent: Double,
+        resetCountdown: String?,
+        severity: UsageSeverity,
+        color: ProviderColorData,
+        updatedAt: Date
+    ) {
+        self.id = id
+        self.displayName = displayName
+        self.usedPercent = usedPercent
+        self.remainingPercent = remainingPercent
+        self.resetCountdown = resetCountdown
+        self.severity = severity
+        self.color = color
+        self.updatedAt = updatedAt
+    }
+
+    /// Create widget data from a provider entry
+    public static func from(entry: WidgetSnapshot.ProviderEntry) -> WidgetProviderData {
+        let descriptor = ProviderDescriptorRegistry.descriptor(for: entry.provider)
+        let metadata = descriptor.metadata
+        let branding = descriptor.branding
+
+        let usedPercent = entry.primary?.usedPercent ?? 0
+        let remainingPercent = entry.primary?.remainingPercent ?? 100
+
+        let severity = UsageSeverity.from(usedPercent: usedPercent)
+
+        let resetCountdown: String?
+        if let resetsAt = entry.primary?.resetsAt {
+            resetCountdown = UsageFormatter.resetCountdownDescription(from: resetsAt)
+        } else {
+            resetCountdown = nil
+        }
+
+        return WidgetProviderData(
+            id: entry.provider,
+            displayName: metadata.displayName,
+            usedPercent: usedPercent,
+            remainingPercent: remainingPercent,
+            resetCountdown: resetCountdown,
+            severity: severity,
+            color: ProviderColorData.from(branding.color),
+            updatedAt: entry.updatedAt
+        )
+    }
+}
+
+// MARK: - Usage Severity
+
+/// Usage severity levels for visual indicators
+///
+/// Determines the color and urgency of usage display.
+public enum UsageSeverity: String, Codable, Hashable {
+    case normal      // 0-60% used
+    case elevated    // 60-80% used
+    case high        // 80-95% used
+    case critical    // 95-100% used
+
+    /// Determine severity from usage percentage
+    public static func from(usedPercent: Double) -> UsageSeverity {
+        switch usedPercent {
+        case 0..<60:
+            return .normal
+        case 60..<80:
+            return .elevated
+        case 80..<95:
+            return .high
+        default:
+            return .critical
+        }
+    }
+
+    /// System color name for this severity
+    public var systemColorName: String {
+        switch self {
+        case .normal:
+            return "green"
+        case .elevated:
+            return "yellow"
+        case .high:
+            return "orange"
+        case .critical:
+            return "red"
+        }
+    }
+}
+
+// MARK: - Provider Color Data
+
+/// Color information for provider branding
+///
+/// SwiftUI-compatible color data extracted from ProviderColor.
+public struct ProviderColorData: Hashable, Codable {
+    public let red: Double
+    public let green: Double
+    public let blue: Double
+
+    public init(red: Double, green: Double, blue: Double) {
+        self.red = red
+        self.green = green
+        self.blue = blue
+    }
+
+    public static func from(_ color: ProviderColor) -> ProviderColorData {
+        ProviderColorData(
+            red: color.red,
+            green: color.green,
+            blue: color.blue
+        )
+    }
+}
+
+// MARK: - Widget Size Helpers
+
+/// Helper for widget family-specific content selection
+public enum WidgetSizeHelper {
+    /// Maximum number of providers for a widget family
+    public static func maxProviders(for family: WidgetFamily) -> Int {
+        switch family {
+        case .systemSmall:
+            return 1
+        case .systemMedium:
+            return 3
+        case .systemLarge, .systemExtraLarge:
+            return 6
+        case .accessoryCircular, .accessoryInline, .accessoryRectangular:
+            return 1
+        @unknown default:
+            return 1
+        }
+    }
+
+    /// Whether to show charts for this widget family
+    public static func showsCharts(for family: WidgetFamily) -> Bool {
+        switch family {
+        case .systemLarge, .systemExtraLarge:
+            return true
+        default:
+            return false
+        }
+    }
+
+    /// Whether to show reset countdown for this widget family
+    public static func showsResetCountdown(for family: WidgetFamily) -> Bool {
+        switch family {
+        case .systemSmall, .systemMedium, .systemLarge, .systemExtraLarge:
+            return true
+        default:
+            return false
+        }
+    }
+}
+
+// MARK: - Placeholder Data
+
+extension RunicWidgetEntry {
+    /// Create a placeholder entry for loading states
+    public static func placeholder(configuration: WidgetConfiguration = .default) -> RunicWidgetEntry {
+        let placeholderProvider = WidgetSnapshot.ProviderEntry(
+            provider: .claude,
+            updatedAt: Date(),
+            primary: RateWindow(
+                usedPercent: 45.0,
+                windowMinutes: 300,
+                resetsAt: Date().addingTimeInterval(3600),
+                resetDescription: "in 1h"
+            ),
+            secondary: RateWindow(
+                usedPercent: 23.0,
+                windowMinutes: 10080,
+                resetsAt: Date().addingTimeInterval(86400),
+                resetDescription: "in 1d"
+            ),
+            tertiary: nil,
+            creditsRemaining: nil,
+            codeReviewRemainingPercent: nil,
+            tokenUsage: nil,
+            dailyUsage: []
+        )
+
+        let snapshot = WidgetSnapshot(
+            entries: [placeholderProvider],
+            enabledProviders: [.claude],
+            generatedAt: Date()
+        )
+
+        return RunicWidgetEntry(
+            date: Date(),
+            snapshot: snapshot,
+            configuration: configuration,
+            isPlaceholder: true
+        )
+    }
+}