@sriinnu/runic 1.0.0

package/Sources/RunicCore/WidgetSnapshot.swift

@@ -0,0 +1,183 @@
+import Foundation
+
+public struct WidgetSnapshot: Codable, Sendable {
+    public struct ProviderEntry: Codable, Sendable {
+        public let provider: UsageProvider
+        public let updatedAt: Date
+        public let primary: RateWindow?
+        public let secondary: RateWindow?
+        public let tertiary: RateWindow?
+        public let creditsRemaining: Double?
+        public let codeReviewRemainingPercent: Double?
+        public let tokenUsage: TokenUsageSummary?
+        public let dailyUsage: [DailyUsagePoint]
+
+        public init(
+            provider: UsageProvider,
+            updatedAt: Date,
+            primary: RateWindow?,
+            secondary: RateWindow?,
+            tertiary: RateWindow?,
+            creditsRemaining: Double?,
+            codeReviewRemainingPercent: Double?,
+            tokenUsage: TokenUsageSummary?,
+            dailyUsage: [DailyUsagePoint])
+        {
+            self.provider = provider
+            self.updatedAt = updatedAt
+            self.primary = primary
+            self.secondary = secondary
+            self.tertiary = tertiary
+            self.creditsRemaining = creditsRemaining
+            self.codeReviewRemainingPercent = codeReviewRemainingPercent
+            self.tokenUsage = tokenUsage
+            self.dailyUsage = dailyUsage
+        }
+    }
+
+    public struct TokenUsageSummary: Codable, Sendable {
+        public let sessionCostUSD: Double?
+        public let sessionTokens: Int?
+        public let last30DaysCostUSD: Double?
+        public let last30DaysTokens: Int?
+
+        public init(
+            sessionCostUSD: Double?,
+            sessionTokens: Int?,
+            last30DaysCostUSD: Double?,
+            last30DaysTokens: Int?)
+        {
+            self.sessionCostUSD = sessionCostUSD
+            self.sessionTokens = sessionTokens
+            self.last30DaysCostUSD = last30DaysCostUSD
+            self.last30DaysTokens = last30DaysTokens
+        }
+    }
+
+    public struct DailyUsagePoint: Codable, Sendable {
+        public let dayKey: String
+        public let totalTokens: Int?
+        public let costUSD: Double?
+
+        public init(dayKey: String, totalTokens: Int?, costUSD: Double?) {
+            self.dayKey = dayKey
+            self.totalTokens = totalTokens
+            self.costUSD = costUSD
+        }
+    }
+
+    public let entries: [ProviderEntry]
+    public let enabledProviders: [UsageProvider]
+    public let generatedAt: Date
+
+    public init(entries: [ProviderEntry], enabledProviders: [UsageProvider]? = nil, generatedAt: Date) {
+        self.entries = entries
+        self.enabledProviders = enabledProviders ?? entries.map(\.provider)
+        self.generatedAt = generatedAt
+    }
+
+    private enum CodingKeys: String, CodingKey {
+        case entries
+        case enabledProviders
+        case generatedAt
+    }
+
+    public init(from decoder: Decoder) throws {
+        let container = try decoder.container(keyedBy: CodingKeys.self)
+        self.entries = try container.decode([ProviderEntry].self, forKey: .entries)
+        self.generatedAt = try container.decode(Date.self, forKey: .generatedAt)
+        self.enabledProviders = try container.decodeIfPresent([UsageProvider].self, forKey: .enabledProviders)
+            ?? self.entries.map(\.provider)
+    }
+
+    public func encode(to encoder: Encoder) throws {
+        var container = encoder.container(keyedBy: CodingKeys.self)
+        try container.encode(self.entries, forKey: .entries)
+        try container.encode(self.enabledProviders, forKey: .enabledProviders)
+        try container.encode(self.generatedAt, forKey: .generatedAt)
+    }
+}
+
+public enum WidgetSnapshotStore {
+    public static let appGroupID = "group.com.sriinnu.athena.runic"
+    private static let filename = "widget-snapshot.json"
+
+    public static func load(bundleID: String? = Bundle.main.bundleIdentifier) -> WidgetSnapshot? {
+        guard let url = self.snapshotURL(bundleID: bundleID) else { return nil }
+        guard let data = try? Data(contentsOf: url) else { return nil }
+        return try? self.decoder.decode(WidgetSnapshot.self, from: data)
+    }
+
+    public static func save(_ snapshot: WidgetSnapshot, bundleID: String? = Bundle.main.bundleIdentifier) {
+        guard let url = self.snapshotURL(bundleID: bundleID) else { return }
+        do {
+            let data = try self.encoder.encode(snapshot)
+            try data.write(to: url, options: [.atomic])
+        } catch {
+            return
+        }
+    }
+
+    private static func snapshotURL(bundleID: String?) -> URL? {
+        let fm = FileManager.default
+        let groupID = self.groupID(for: bundleID)
+        #if os(macOS)
+        if let groupID, let container = fm.containerURL(forSecurityApplicationGroupIdentifier: groupID) {
+            return container.appendingPathComponent(self.filename, isDirectory: false)
+        }
+        #endif
+
+        let base = fm.urls(for: .applicationSupportDirectory, in: .userDomainMask).first
+            ?? fm.temporaryDirectory
+        let dir = base.appendingPathComponent("Runic", isDirectory: true)
+        try? fm.createDirectory(at: dir, withIntermediateDirectories: true)
+        return dir.appendingPathComponent(self.filename, isDirectory: false)
+    }
+
+    public static func appGroupID(for bundleID: String?) -> String? {
+        self.groupID(for: bundleID)
+    }
+
+    private static func groupID(for bundleID: String?) -> String? {
+        guard let bundleID, !bundleID.isEmpty else { return self.appGroupID }
+        if bundleID.contains(".debug") {
+            return "group.com.sriinnu.athena.runic.debug"
+        }
+        return self.appGroupID
+    }
+
+    private static var encoder: JSONEncoder {
+        let encoder = JSONEncoder()
+        encoder.dateEncodingStrategy = .iso8601
+        return encoder
+    }
+
+    private static var decoder: JSONDecoder {
+        let decoder = JSONDecoder()
+        decoder.dateDecodingStrategy = .iso8601
+        return decoder
+    }
+}
+
+public enum WidgetSelectionStore {
+    private static let selectedProviderKey = "widgetSelectedProvider"
+
+    public static func loadSelectedProvider(bundleID: String? = Bundle.main.bundleIdentifier) -> UsageProvider? {
+        guard let defaults = self.sharedDefaults(bundleID: bundleID) else { return nil }
+        guard let raw = defaults.string(forKey: self.selectedProviderKey) else { return nil }
+        return UsageProvider(rawValue: raw)
+    }
+
+    public static func saveSelectedProvider(
+        _ provider: UsageProvider,
+        bundleID: String? = Bundle.main.bundleIdentifier)
+    {
+        guard let defaults = self.sharedDefaults(bundleID: bundleID) else { return }
+        defaults.set(provider.rawValue, forKey: self.selectedProviderKey)
+    }
+
+    private static func sharedDefaults(bundleID: String?) -> UserDefaults? {
+        guard let groupID = WidgetSnapshotStore.appGroupID(for: bundleID) else { return nil }
+        return UserDefaults(suiteName: groupID)
+    }
+}

package/Sources/RunicMacroSupport/ProviderRegistrationMacros.swift

@@ -0,0 +1,14 @@
+@attached(peer, names: prefixed(_RunicDescriptorRegistration_))
+public macro ProviderDescriptorRegistration() = #externalMacro(
+    module: "RunicMacros",
+    type: "ProviderDescriptorRegistrationMacro")
+
+@attached(member, names: named(descriptor))
+public macro ProviderDescriptorDefinition() = #externalMacro(
+    module: "RunicMacros",
+    type: "ProviderDescriptorDefinitionMacro")
+
+@attached(peer, names: prefixed(_RunicImplementationRegistration_))
+public macro ProviderImplementationRegistration() = #externalMacro(
+    module: "RunicMacros",
+    type: "ProviderImplementationRegistrationMacro")

package/Sources/RunicMacros/ProviderRegistrationMacros.swift

@@ -0,0 +1,216 @@
+import SwiftCompilerPlugin
+import SwiftDiagnostics
+import SwiftSyntax
+import SwiftSyntaxBuilder
+import SwiftSyntaxMacros
+
+private enum ProviderMacroError {
+    struct Message: DiagnosticMessage {
+        let message: String
+        let diagnosticID: MessageID
+        let severity: DiagnosticSeverity
+    }
+
+    static func unsupportedTarget(_ context: some MacroExpansionContext, node: SyntaxProtocol, macro: String) {
+        context.diagnose(Diagnostic(
+            node: node,
+            message: Message(
+                message: "@\(macro) must be attached to a struct, class, or enum.",
+                diagnosticID: MessageID(domain: "RunicMacros", id: "unsupported_target"),
+                severity: .error)))
+    }
+
+    static func missingDescriptor(_ context: some MacroExpansionContext, node: SyntaxProtocol, typeName: String) {
+        context.diagnose(Diagnostic(
+            node: node,
+            message: Message(
+                message: "\(typeName) must declare static let descriptor or static func makeDescriptor() " +
+                    "to use @ProviderDescriptorRegistration.",
+                diagnosticID: MessageID(domain: "RunicMacros", id: "missing_descriptor"),
+                severity: .error)))
+    }
+
+    static func missingMakeDescriptor(_ context: some MacroExpansionContext, node: SyntaxProtocol, typeName: String) {
+        context.diagnose(Diagnostic(
+            node: node,
+            message: Message(
+                message: "\(typeName) must declare static func makeDescriptor() to use @ProviderDescriptorDefinition.",
+                diagnosticID: MessageID(domain: "RunicMacros", id: "missing_make_descriptor"),
+                severity: .error)))
+    }
+
+    static func duplicateDescriptor(_ context: some MacroExpansionContext, node: SyntaxProtocol, typeName: String) {
+        context.diagnose(Diagnostic(
+            node: node,
+            message: Message(
+                message: "\(typeName) already declares descriptor; remove @ProviderDescriptorDefinition.",
+                diagnosticID: MessageID(domain: "RunicMacros", id: "duplicate_descriptor"),
+                severity: .error)))
+    }
+
+    static func missingInit(_ context: some MacroExpansionContext, node: SyntaxProtocol, typeName: String) {
+        context.diagnose(Diagnostic(
+            node: node,
+            message: Message(
+                message: "\(typeName) must provide an init() to use @ProviderImplementationRegistration.",
+                diagnosticID: MessageID(domain: "RunicMacros", id: "missing_init"),
+                severity: .error)))
+    }
+}
+
+private enum ProviderMacroIntrospection {
+    static func typeDecl(from declaration: some DeclSyntaxProtocol) -> (decl: DeclGroupSyntax, name: String)? {
+        if let decl = declaration.as(StructDeclSyntax.self) { return (decl, decl.name.text) }
+        if let decl = declaration.as(ClassDeclSyntax.self) { return (decl, decl.name.text) }
+        if let decl = declaration.as(EnumDeclSyntax.self) { return (decl, decl.name.text) }
+        return nil
+    }
+
+    static func hasStaticDescriptor(in decl: DeclGroupSyntax) -> Bool {
+        for member in decl.memberBlock.members {
+            guard let varDecl = member.decl.as(VariableDeclSyntax.self) else { continue }
+            guard self.isStatic(varDecl.modifiers) else { continue }
+            for binding in varDecl.bindings {
+                guard let pattern = binding.pattern.as(IdentifierPatternSyntax.self) else { continue }
+                if pattern.identifier.text == "descriptor" { return true }
+            }
+        }
+        return false
+    }
+
+    static func hasMakeDescriptor(in decl: DeclGroupSyntax) -> Bool {
+        for member in decl.memberBlock.members {
+            guard let funcDecl = member.decl.as(FunctionDeclSyntax.self) else { continue }
+            guard self.isStatic(funcDecl.modifiers) else { continue }
+            if funcDecl.name.text == "makeDescriptor" { return true }
+        }
+        return false
+    }
+
+    static func hasAccessibleInit(in decl: DeclGroupSyntax) -> Bool {
+        if self.hasZeroArgInit(in: decl) { return true }
+        if decl.is(EnumDeclSyntax.self) { return false }
+        return self.canSynthesizeDefaultInit(in: decl)
+    }
+
+    private static func hasZeroArgInit(in decl: DeclGroupSyntax) -> Bool {
+        for member in decl.memberBlock.members {
+            guard let initDecl = member.decl.as(InitializerDeclSyntax.self) else { continue }
+            let params = initDecl.signature.parameterClause.parameters
+            if params.isEmpty { return true }
+            let allDefaulted = params.allSatisfy { $0.defaultValue != nil }
+            if allDefaulted { return true }
+        }
+        return false
+    }
+
+    private static func canSynthesizeDefaultInit(in decl: DeclGroupSyntax) -> Bool {
+        for member in decl.memberBlock.members {
+            guard let varDecl = member.decl.as(VariableDeclSyntax.self) else { continue }
+            guard !self.isStatic(varDecl.modifiers) else { continue }
+            for binding in varDecl.bindings {
+                if binding.accessorBlock != nil { continue }
+                if binding.initializer == nil { return false }
+            }
+        }
+        return true
+    }
+
+    private static func isStatic(_ modifiers: DeclModifierListSyntax?) -> Bool {
+        guard let modifiers else { return false }
+        return modifiers.contains { $0.name.tokenKind == .keyword(.static) }
+    }
+}
+
+public struct ProviderDescriptorRegistrationMacro: PeerMacro {
+    public static func expansion(
+        of _: AttributeSyntax,
+        providingPeersOf declaration: some DeclSyntaxProtocol,
+        in context: some MacroExpansionContext) throws -> [DeclSyntax]
+    {
+        guard let (decl, typeName) = ProviderMacroIntrospection.typeDecl(from: declaration) else {
+            ProviderMacroError.unsupportedTarget(
+                context,
+                node: Syntax(declaration),
+                macro: "ProviderDescriptorRegistration")
+            return []
+        }
+
+        let hasDescriptor = ProviderMacroIntrospection.hasStaticDescriptor(in: decl)
+        let hasMakeDescriptor = ProviderMacroIntrospection.hasMakeDescriptor(in: decl)
+        guard hasDescriptor || hasMakeDescriptor else {
+            ProviderMacroError.missingDescriptor(context, node: Syntax(declaration), typeName: typeName)
+            return []
+        }
+
+        let registerName = "_RunicDescriptorRegistration_\(typeName)"
+        return [
+            DeclSyntax(
+                "private let \(raw: registerName) = ProviderDescriptorRegistry.register(\(raw: typeName).descriptor)"),
+        ]
+    }
+}
+
+public struct ProviderDescriptorDefinitionMacro: MemberMacro {
+    public static func expansion(
+        of _: AttributeSyntax,
+        providingMembersOf declaration: some DeclGroupSyntax,
+        in context: some MacroExpansionContext) throws -> [DeclSyntax]
+    {
+        guard let (decl, typeName) = ProviderMacroIntrospection.typeDecl(from: declaration) else {
+            ProviderMacroError.unsupportedTarget(
+                context,
+                node: Syntax(declaration),
+                macro: "ProviderDescriptorDefinition")
+            return []
+        }
+
+        if ProviderMacroIntrospection.hasStaticDescriptor(in: decl) {
+            ProviderMacroError.duplicateDescriptor(context, node: Syntax(declaration), typeName: typeName)
+            return []
+        }
+
+        guard ProviderMacroIntrospection.hasMakeDescriptor(in: decl) else {
+            ProviderMacroError.missingMakeDescriptor(context, node: Syntax(declaration), typeName: typeName)
+            return []
+        }
+
+        return [DeclSyntax("public static let descriptor: ProviderDescriptor = Self.makeDescriptor()")]
+    }
+}
+
+public struct ProviderImplementationRegistrationMacro: PeerMacro {
+    public static func expansion(
+        of _: AttributeSyntax,
+        providingPeersOf declaration: some DeclSyntaxProtocol,
+        in context: some MacroExpansionContext) throws -> [DeclSyntax]
+    {
+        guard let (decl, typeName) = ProviderMacroIntrospection.typeDecl(from: declaration) else {
+            ProviderMacroError.unsupportedTarget(
+                context,
+                node: Syntax(declaration),
+                macro: "ProviderImplementationRegistration")
+            return []
+        }
+
+        guard ProviderMacroIntrospection.hasAccessibleInit(in: decl) else {
+            ProviderMacroError.missingInit(context, node: Syntax(declaration), typeName: typeName)
+            return []
+        }
+
+        let registerName = "_RunicImplementationRegistration_\(typeName)"
+        return [
+            DeclSyntax(
+                "private let \(raw: registerName) = ProviderImplementationRegistry.register(\(raw: typeName)())"),
+        ]
+    }
+}
+
+@main
+struct RunicMacroPlugin: CompilerPlugin {
+    let providingMacros: [Macro.Type] = [
+        ProviderDescriptorRegistrationMacro.self,
+        ProviderDescriptorDefinitionMacro.self,
+        ProviderImplementationRegistrationMacro.self,
+    ]
+}

package/Sources/RunicWidget/RunicWidgetBundle.swift

@@ -0,0 +1,79 @@
+import SwiftUI
+import WidgetKit
+
+@main
+struct RunicWidgetBundle: WidgetBundle {
+    var body: some Widget {
+        RunicSwitcherWidget()
+        RunicUsageWidget()
+        RunicHistoryWidget()
+        RunicCompactWidget()
+    }
+}
+
+struct RunicSwitcherWidget: Widget {
+    private let kind = "RunicSwitcherWidget"
+
+    var body: some WidgetConfiguration {
+        StaticConfiguration(
+            kind: self.kind,
+            provider: RunicSwitcherTimelineProvider())
+        { entry in
+            RunicSwitcherWidgetView(entry: entry)
+        }
+        .configurationDisplayName("Runic Switcher")
+        .description("Usage widget with a provider switcher.")
+        .supportedFamilies([.systemSmall, .systemMedium, .systemLarge])
+    }
+}
+
+struct RunicUsageWidget: Widget {
+    private let kind = "RunicUsageWidget"
+
+    var body: some WidgetConfiguration {
+        AppIntentConfiguration(
+            kind: self.kind,
+            intent: ProviderSelectionIntent.self,
+            provider: RunicTimelineProvider())
+        { entry in
+            RunicUsageWidgetView(entry: entry)
+        }
+        .configurationDisplayName("Runic Usage")
+        .description("Session and weekly usage with credits and costs.")
+        .supportedFamilies([.systemSmall, .systemMedium, .systemLarge])
+    }
+}
+
+struct RunicHistoryWidget: Widget {
+    private let kind = "RunicHistoryWidget"
+
+    var body: some WidgetConfiguration {
+        AppIntentConfiguration(
+            kind: self.kind,
+            intent: ProviderSelectionIntent.self,
+            provider: RunicTimelineProvider())
+        { entry in
+            RunicHistoryWidgetView(entry: entry)
+        }
+        .configurationDisplayName("Runic History")
+        .description("Usage history chart with recent totals.")
+        .supportedFamilies([.systemMedium, .systemLarge])
+    }
+}
+
+struct RunicCompactWidget: Widget {
+    private let kind = "RunicCompactWidget"
+
+    var body: some WidgetConfiguration {
+        AppIntentConfiguration(
+            kind: self.kind,
+            intent: CompactMetricSelectionIntent.self,
+            provider: RunicCompactTimelineProvider())
+        { entry in
+            RunicCompactWidgetView(entry: entry)
+        }
+        .configurationDisplayName("Runic Metric")
+        .description("Compact widget for credits or cost.")
+        .supportedFamilies([.systemSmall])
+    }
+}