@sriinnu/runic 1.0.0

package/RuniciOS/Widgets/LiveActivity.swift

@@ -0,0 +1,342 @@
+import SwiftUI
+import ActivityKit
+import WidgetKit
+import RunicCore
+
+// MARK: - Live Activity Attributes
+
+/// Attributes for Runic Live Activities
+///
+/// Defines the static and dynamic data for Live Activities showing active AI sessions.
+struct RunicLiveActivityAttributes: ActivityAttributes {
+    /// Static data that doesn't change during the activity
+    public struct ContentState: Codable, Hashable {
+        /// Current provider being used
+        var provider: UsageProvider
+
+        /// Provider display name
+        var providerName: String
+
+        /// Current usage percentage
+        var usedPercent: Double
+
+        /// Remaining percentage
+        var remainingPercent: Double
+
+        /// Session start time
+        var sessionStartTime: Date
+
+        /// Total tokens used in session (if available)
+        var sessionTokens: Int?
+
+        /// Estimated cost in USD (if available)
+        var estimatedCost: Double?
+
+        /// Reset time for the current window
+        var resetsAt: Date?
+
+        /// Session status
+        var status: SessionStatus
+
+        public enum SessionStatus: String, Codable {
+            case active = "active"
+            case paused = "paused"
+            case nearLimit = "near_limit"
+            case complete = "complete"
+        }
+    }
+
+    /// Provider color for branding
+    var providerColor: ProviderColorData
+
+    /// Session identifier
+    var sessionID: String
+
+    /// Activity title
+    var activityTitle: String
+}
+
+// MARK: - Live Activity Widget
+
+/// Live Activity widget for active AI sessions
+///
+/// Shows real-time usage updates during active coding sessions.
+@available(iOS 16.1, *)
+struct RunicLiveActivity: Widget {
+    var body: some WidgetConfiguration {
+        ActivityConfiguration(for: RunicLiveActivityAttributes.self) { context in
+            // Lock screen / banner UI
+            LiveActivityView(context: context)
+                .padding(.horizontal, 16)
+                .padding(.vertical, 12)
+                .activityBackgroundTint(Color.black.opacity(0.8))
+                .activitySystemActionForegroundColor(Color.white)
+
+        } dynamicIsland: { context in
+            DynamicIsland {
+                // Expanded view
+                DynamicIslandExpandedRegion(.leading) {
+                    expandedLeading(context: context)
+                }
+                DynamicIslandExpandedRegion(.trailing) {
+                    expandedTrailing(context: context)
+                }
+                DynamicIslandExpandedRegion(.center) {
+                    expandedCenter(context: context)
+                }
+                DynamicIslandExpandedRegion(.bottom) {
+                    expandedBottom(context: context)
+                }
+            } compactLeading: {
+                compactLeading(context: context)
+            } compactTrailing: {
+                compactTrailing(context: context)
+            } minimal: {
+                minimal(context: context)
+            }
+            .keylineTint(providerColor(context: context))
+        }
+    }
+
+    // MARK: - Lock Screen / Banner Views
+
+    @ViewBuilder
+    func LiveActivityView(context: ActivityViewContext<RunicLiveActivityAttributes>) -> some View {
+        VStack(spacing: 12) {
+            HStack {
+                Circle().fill(providerColor(context: context)).frame(width: 10, height: 10)
+                Text(context.state.providerName).font(.system(size: 15, weight: .semibold)).foregroundColor(.white)
+                Spacer()
+                statusBadge(for: context.state.status)
+            }
+
+            VStack(spacing: 6) {
+                HStack {
+                    Text("Session Usage").font(.system(size: 12, weight: .medium)).foregroundColor(.white.opacity(0.7))
+                    Spacer()
+                    Text("\(Int(context.state.remainingPercent))% remaining").font(.system(size: 12, weight: .semibold)).foregroundColor(.white)
+                }
+                GeometryReader { geometry in
+                    ZStack(alignment: .leading) {
+                        RoundedRectangle(cornerRadius: 4).fill(Color.white.opacity(0.15))
+                        RoundedRectangle(cornerRadius: 4).fill(usageGradient(for: context.state.usedPercent))
+                            .frame(width: geometry.size.width * (context.state.usedPercent / 100))
+                    }
+                }
+                .frame(height: 8)
+            }
+
+            HStack {
+                HStack(spacing: 4) {
+                    Image(systemName: "clock.fill").font(.system(size: 10)).foregroundColor(.white.opacity(0.6))
+                    Text(sessionDuration(from: context.state.sessionStartTime)).font(.system(size: 11, weight: .medium)).foregroundColor(.white.opacity(0.8))
+                }
+                Spacer()
+                if let tokens = context.state.sessionTokens {
+                    HStack(spacing: 4) {
+                        Image(systemName: "number").font(.system(size: 10)).foregroundColor(.white.opacity(0.6))
+                        Text(UsageFormatter.tokenCountString(tokens)).font(.system(size: 11, weight: .medium)).foregroundColor(.white.opacity(0.8))
+                    }
+                }
+                if let cost = context.state.estimatedCost {
+                    HStack(spacing: 4) {
+                        Image(systemName: "dollarsign.circle.fill").font(.system(size: 10)).foregroundColor(.white.opacity(0.6))
+                        Text(UsageFormatter.usdString(cost)).font(.system(size: 11, weight: .medium)).foregroundColor(.white.opacity(0.8))
+                    }
+                }
+            }
+        }
+    }
+
+    // MARK: - Dynamic Island Views
+
+    @ViewBuilder
+    func expandedLeading(context: ActivityViewContext<RunicLiveActivityAttributes>) -> some View {
+        VStack(alignment: .leading, spacing: 4) {
+            Text(context.state.providerName)
+                .font(.system(size: 14, weight: .semibold))
+
+            Text(sessionDuration(from: context.state.sessionStartTime))
+                .font(.system(size: 12, weight: .medium))
+                .foregroundColor(.secondary)
+        }
+    }
+
+    @ViewBuilder
+    func expandedTrailing(context: ActivityViewContext<RunicLiveActivityAttributes>) -> some View {
+        VStack(alignment: .trailing, spacing: 4) {
+            Text("\(Int(context.state.remainingPercent))%")
+                .font(.system(size: 18, weight: .bold, design: .rounded))
+
+            Text("remaining")
+                .font(.system(size: 11, weight: .medium))
+                .foregroundColor(.secondary)
+        }
+    }
+
+    @ViewBuilder
+    func expandedCenter(context: ActivityViewContext<RunicLiveActivityAttributes>) -> some View {
+        EmptyView()
+    }
+
+    @ViewBuilder
+    func expandedBottom(context: ActivityViewContext<RunicLiveActivityAttributes>) -> some View {
+        VStack(spacing: 8) {
+            GeometryReader { geometry in
+                ZStack(alignment: .leading) {
+                    Capsule().fill(Color.secondary.opacity(0.2))
+                    Capsule().fill(usageGradient(for: context.state.usedPercent))
+                        .frame(width: geometry.size.width * (context.state.usedPercent / 100))
+                }
+            }
+            .frame(height: 6)
+
+            HStack {
+                if let tokens = context.state.sessionTokens { statItem(icon: "number", value: UsageFormatter.tokenCountString(tokens)) }
+                if let cost = context.state.estimatedCost { statItem(icon: "dollarsign.circle", value: UsageFormatter.usdString(cost)) }
+                Spacer()
+            }
+            .font(.system(size: 11))
+        }
+    }
+
+    @ViewBuilder
+    func compactLeading(context: ActivityViewContext<RunicLiveActivityAttributes>) -> some View {
+        Circle()
+            .fill(providerColor(context: context))
+            .frame(width: 8, height: 8)
+    }
+
+    @ViewBuilder
+    func compactTrailing(context: ActivityViewContext<RunicLiveActivityAttributes>) -> some View {
+        Text("\(Int(context.state.remainingPercent))%")
+            .font(.system(size: 12, weight: .bold, design: .rounded))
+    }
+
+    @ViewBuilder
+    func minimal(context: ActivityViewContext<RunicLiveActivityAttributes>) -> some View {
+        Circle()
+            .fill(providerColor(context: context))
+            .frame(width: 8, height: 8)
+    }
+
+    // MARK: - Helper Views & Methods
+
+    private func statusBadge(for status: RunicLiveActivityAttributes.ContentState.SessionStatus) -> some View {
+        let (text, color, icon) = status == .active ? ("Active", Color.green, "play.circle.fill") :
+            status == .paused ? ("Paused", Color.orange, "pause.circle.fill") :
+            status == .nearLimit ? ("Near Limit", Color.red, "exclamationmark.circle.fill") :
+            ("Complete", Color.blue, "checkmark.circle.fill")
+
+        return HStack(spacing: 4) {
+            Image(systemName: icon).font(.system(size: 10))
+            Text(text).font(.system(size: 11, weight: .semibold))
+        }
+        .foregroundColor(color)
+        .padding(.horizontal, 8).padding(.vertical, 4)
+        .background(color.opacity(0.2))
+        .clipShape(Capsule())
+    }
+
+    private func statItem(icon: String, value: String) -> some View {
+        HStack(spacing: 4) {
+            Image(systemName: icon).font(.system(size: 10)).foregroundColor(.secondary)
+            Text(value).font(.system(size: 11, weight: .medium))
+        }
+    }
+
+    private func sessionDuration(from startTime: Date) -> String {
+        let duration = Date().timeIntervalSince(startTime)
+        let hours = Int(duration) / 3600
+        let minutes = (Int(duration) % 3600) / 60
+        return hours > 0 ? "\(hours)h \(minutes)m" : "\(minutes)m"
+    }
+
+    private func usageGradient(for usedPercent: Double) -> LinearGradient {
+        let color: Color = usedPercent < 60 ? .green : usedPercent < 80 ? .yellow : usedPercent < 95 ? .orange : .red
+        return LinearGradient(colors: [color, color.opacity(0.7)], startPoint: .leading, endPoint: .trailing)
+    }
+
+    private func providerColor(context: ActivityViewContext<RunicLiveActivityAttributes>) -> Color {
+        Color(red: context.attributes.providerColor.red, green: context.attributes.providerColor.green, blue: context.attributes.providerColor.blue)
+    }
+}
+
+// MARK: - Live Activity Manager
+
+/// Manager for starting and updating Live Activities
+@available(iOS 16.1, *)
+public enum RunicLiveActivityManager {
+    /// Start a new Live Activity for a coding session
+    public static func startActivity(
+        provider: UsageProvider,
+        providerName: String,
+        providerColor: ProviderColorData,
+        usedPercent: Double
+    ) async throws -> String {
+        let attributes = RunicLiveActivityAttributes(
+            providerColor: providerColor,
+            sessionID: UUID().uuidString,
+            activityTitle: "\(providerName) Session"
+        )
+
+        let initialState = RunicLiveActivityAttributes.ContentState(
+            provider: provider,
+            providerName: providerName,
+            usedPercent: usedPercent,
+            remainingPercent: 100 - usedPercent,
+            sessionStartTime: Date(),
+            sessionTokens: nil,
+            estimatedCost: nil,
+            resetsAt: nil,
+            status: .active
+        )
+
+        let activity = try Activity.request(
+            attributes: attributes,
+            contentState: initialState,
+            pushType: nil
+        )
+
+        return activity.id
+    }
+
+    /// Update an existing Live Activity
+    public static func updateActivity(
+        activityID: String,
+        usedPercent: Double,
+        sessionTokens: Int?,
+        estimatedCost: Double?,
+        status: RunicLiveActivityAttributes.ContentState.SessionStatus
+    ) async {
+        for activity in Activity<RunicLiveActivityAttributes>.activities where activity.id == activityID {
+            let updatedState = RunicLiveActivityAttributes.ContentState(
+                provider: activity.contentState.provider,
+                providerName: activity.contentState.providerName,
+                usedPercent: usedPercent,
+                remainingPercent: 100 - usedPercent,
+                sessionStartTime: activity.contentState.sessionStartTime,
+                sessionTokens: sessionTokens,
+                estimatedCost: estimatedCost,
+                resetsAt: activity.contentState.resetsAt,
+                status: status
+            )
+
+            await activity.update(using: updatedState)
+        }
+    }
+
+    /// End a Live Activity
+    public static func endActivity(activityID: String) async {
+        for activity in Activity<RunicLiveActivityAttributes>.activities where activity.id == activityID {
+            await activity.end(dismissalPolicy: .default)
+        }
+    }
+
+    /// End all active Runic Live Activities
+    public static func endAllActivities() async {
+        for activity in Activity<RunicLiveActivityAttributes>.activities {
+            await activity.end(dismissalPolicy: .immediate)
+        }
+    }
+}

package/RuniciOS/Widgets/LockScreenWidget.swift

@@ -0,0 +1,273 @@
+import SwiftUI
+import WidgetKit
+import RunicCore
+
+// MARK: - Lock Screen Widget Configuration
+
+/// Lock screen widget bundle
+///
+/// Provides circular, rectangular, and inline widgets for the iOS lock screen.
+/// These widgets are optimized for minimal battery impact and quick glanceability.
+struct RunicLockScreenWidget: Widget {
+    let kind: String = "RunicLockScreenWidget"
+
+    var body: some WidgetConfiguration {
+        StaticConfiguration(
+            kind: kind,
+            provider: RunicTimelineProvider()
+        ) { entry in
+            LockScreenWidgetView(entry: entry)
+        }
+        .configurationDisplayName("Runic Lock Screen")
+        .description("Quick glance at usage on your lock screen.")
+        .supportedFamilies([
+            .accessoryCircular,
+            .accessoryRectangular,
+            .accessoryInline
+        ])
+    }
+}
+
+// MARK: - Lock Screen Widget Router
+
+/// Routes to appropriate lock screen widget view based on family
+struct LockScreenWidgetView: View {
+    @Environment(\.widgetFamily) var family
+    let entry: RunicWidgetEntry
+
+    var body: some View {
+        switch family {
+        case .accessoryCircular:
+            LockScreenCircularView(entry: entry)
+
+        case .accessoryRectangular:
+            LockScreenRectangularView(entry: entry)
+
+        case .accessoryInline:
+            LockScreenInlineView(entry: entry)
+
+        default:
+            EmptyView()
+        }
+    }
+}
+
+// MARK: - Circular Lock Screen Widget
+
+/// Circular lock screen widget showing single provider progress
+///
+/// Displays a compact circular gauge with usage percentage.
+struct LockScreenCircularView: View {
+    let entry: RunicWidgetEntry
+
+    var body: some View {
+        if let provider = primaryProvider {
+            ZStack {
+                // Progress ring
+                Circle()
+                    .stroke(Color.white.opacity(0.2), lineWidth: 3)
+
+                Circle()
+                    .trim(from: 0, to: provider.usedPercent / 100)
+                    .stroke(
+                        severityColor(for: provider),
+                        style: StrokeStyle(lineWidth: 3, lineCap: .round)
+                    )
+                    .rotationEffect(.degrees(-90))
+
+                // Center content
+                VStack(spacing: 1) {
+                    Text("\(Int(provider.remainingPercent))")
+                        .font(.system(size: 18, weight: .bold, design: .rounded))
+
+                    Text("%")
+                        .font(.system(size: 10, weight: .semibold))
+                        .opacity(0.8)
+                }
+            }
+            .widgetAccentable()
+        } else {
+            // Placeholder
+            ZStack {
+                Circle()
+                    .stroke(Color.white.opacity(0.2), lineWidth: 3)
+
+                Image(systemName: "exclamationmark.triangle")
+                    .font(.system(size: 16))
+                    .opacity(0.5)
+            }
+        }
+    }
+
+    private var primaryProvider: WidgetProviderData? {
+        entry.providers(for: .accessoryCircular).first
+    }
+
+    private func severityColor(for provider: WidgetProviderData) -> Color {
+        switch provider.severity {
+        case .normal: return .green
+        case .elevated: return .yellow
+        case .high: return .orange
+        case .critical: return .red
+        }
+    }
+}
+
+// MARK: - Rectangular Lock Screen Widget
+
+/// Rectangular lock screen widget showing provider details
+///
+/// Displays provider name, usage bar, and reset countdown.
+struct LockScreenRectangularView: View {
+    let entry: RunicWidgetEntry
+
+    var body: some View {
+        if let provider = primaryProvider {
+            VStack(alignment: .leading, spacing: 4) {
+                // Provider name and percentage
+                HStack {
+                    Text(provider.displayName)
+                        .font(.system(size: 13, weight: .semibold))
+
+                    Spacer()
+
+                    Text("\(Int(provider.remainingPercent))%")
+                        .font(.system(size: 13, weight: .bold, design: .rounded))
+                }
+
+                // Progress bar
+                GeometryReader { geometry in
+                    ZStack(alignment: .leading) {
+                        RoundedRectangle(cornerRadius: 2)
+                            .fill(Color.white.opacity(0.2))
+
+                        RoundedRectangle(cornerRadius: 2)
+                            .fill(severityColor(for: provider))
+                            .frame(width: geometry.size.width * (provider.usedPercent / 100))
+                    }
+                }
+                .frame(height: 6)
+
+                // Reset countdown
+                if let countdown = provider.resetCountdown {
+                    Text("Resets \(countdown)")
+                        .font(.system(size: 11, weight: .medium))
+                        .opacity(0.7)
+                } else {
+                    Text("Updated \(relativeTime(from: provider.updatedAt))")
+                        .font(.system(size: 11, weight: .medium))
+                        .opacity(0.7)
+                }
+            }
+            .widgetAccentable()
+        } else {
+            // Placeholder
+            VStack(alignment: .leading, spacing: 4) {
+                HStack {
+                    Image(systemName: "exclamationmark.triangle")
+                        .font(.system(size: 12))
+
+                    Text("No Data")
+                        .font(.system(size: 13, weight: .semibold))
+                }
+
+                Text("Open Runic to sync")
+                    .font(.system(size: 11))
+                    .opacity(0.6)
+            }
+        }
+    }
+
+    private var primaryProvider: WidgetProviderData? {
+        entry.providers(for: .accessoryRectangular).first
+    }
+
+    private func severityColor(for provider: WidgetProviderData) -> Color {
+        switch provider.severity {
+        case .normal: return .green
+        case .elevated: return .yellow
+        case .high: return .orange
+        case .critical: return .red
+        }
+    }
+
+    private func relativeTime(from date: Date) -> String {
+        let interval = Date().timeIntervalSince(date)
+        let minutes = Int(interval / 60)
+
+        if minutes < 1 { return "now" }
+        if minutes < 60 { return "\(minutes)m ago" }
+        let hours = minutes / 60
+        return "\(hours)h ago"
+    }
+}
+
+// MARK: - Inline Lock Screen Widget
+
+/// Inline lock screen widget showing compact usage summary
+///
+/// Displays a single line of text with provider name and percentage.
+struct LockScreenInlineView: View {
+    let entry: RunicWidgetEntry
+
+    var body: some View {
+        if let provider = primaryProvider {
+            HStack(spacing: 4) {
+                Image(systemName: statusIcon(for: provider))
+                    .font(.system(size: 12))
+
+                Text("\(provider.displayName):")
+                    .font(.system(size: 12, weight: .medium))
+
+                Text("\(Int(provider.remainingPercent))% left")
+                    .font(.system(size: 12, weight: .semibold))
+            }
+        } else {
+            HStack(spacing: 4) {
+                Image(systemName: "exclamationmark.triangle")
+                    .font(.system(size: 12))
+
+                Text("Runic: No data")
+                    .font(.system(size: 12, weight: .medium))
+            }
+        }
+    }
+
+    private var primaryProvider: WidgetProviderData? {
+        entry.providers(for: .accessoryInline).first
+    }
+
+    private func statusIcon(for provider: WidgetProviderData) -> String {
+        switch provider.severity {
+        case .normal: return "checkmark.circle.fill"
+        case .elevated: return "minus.circle.fill"
+        case .high: return "exclamationmark.circle.fill"
+        case .critical: return "xmark.circle.fill"
+        }
+    }
+}
+
+// MARK: - Preview Provider
+
+struct LockScreenWidget_Previews: PreviewProvider {
+    static var previews: some View {
+        let entry = RunicWidgetEntry.placeholder()
+
+        Group {
+            // Circular preview
+            LockScreenCircularView(entry: entry)
+                .previewContext(WidgetPreviewContext(family: .accessoryCircular))
+                .previewDisplayName("Circular")
+
+            // Rectangular preview
+            LockScreenRectangularView(entry: entry)
+                .previewContext(WidgetPreviewContext(family: .accessoryRectangular))
+                .previewDisplayName("Rectangular")
+
+            // Inline preview
+            LockScreenInlineView(entry: entry)
+                .previewContext(WidgetPreviewContext(family: .accessoryInline))
+                .previewDisplayName("Inline")
+        }
+    }
+}