@sriinnu/runic 1.2.0 → 2.11.1

package/RuniciOS/Widgets/LiveActivity.swift

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

@@ -1,273 +0,0 @@
-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")
-        }
-    }
-}