@sriinnu/runic 1.2.0 → 2.11.1

package/Sources/RunicCore/WidgetSnapshot.swift

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

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

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

@@ -1,79 +0,0 @@
-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])
-    }
-}