@sriinnu/runic 1.0.0

package/Sources/RunicCore/Models/EnhancedUsageModels.swift

@@ -0,0 +1,371 @@
+// Enhanced Usage Models for Multi-Platform Runic
+// Tracks subscription types, model usage, projects, and reset timing
+
+import Foundation
+
+// MARK: - User Account Type
+
+/// Distinguishes between usage-based and subscription-based users
+public enum AccountType: String, Codable, Sendable {
+    case usageBased = "usage_based"
+    case subscription = "subscription"
+    case freeTier = "free_tier"
+    case enterprise = "enterprise"
+    case unknown = "unknown"
+}
+
+// MARK: - Usage Reset Information
+
+/// Tracks when usage limits reset
+public struct UsageResetInfo: Codable, Sendable, Hashable {
+    public let resetType: ResetType
+    public let resetAt: Date?
+    public let windowDuration: TimeInterval? // in seconds
+    public let resetsAutomatically: Bool
+
+    public enum ResetType: String, Codable, Sendable {
+        case hourly = "hourly"
+        case daily = "daily"
+        case weekly = "weekly"
+        case monthly = "monthly"
+        case sessionBased = "session" // 5-hour windows, etc.
+        case manual = "manual"
+        case never = "never"
+    }
+
+    public init(
+        resetType: ResetType,
+        resetAt: Date? = nil,
+        windowDuration: TimeInterval? = nil,
+        resetsAutomatically: Bool = true
+    ) {
+        self.resetType = resetType
+        self.resetAt = resetAt
+        self.windowDuration = windowDuration
+        self.resetsAutomatically = resetsAutomatically
+    }
+
+    /// Time remaining until reset
+    public var timeUntilReset: TimeInterval? {
+        guard let resetAt else { return nil }
+        return resetAt.timeIntervalSinceNow
+    }
+
+    /// Human-readable reset description
+    public var resetDescription: String {
+        if let resetAt, let remaining = timeUntilReset, remaining > 0 {
+            let hours = Int(remaining / 3600)
+            let minutes = Int((remaining.truncatingRemainder(dividingBy: 3600)) / 60)
+
+            if hours > 24 {
+                let days = hours / 24
+                return "Resets in \(days)d"
+            } else if hours > 0 {
+                return "Resets in \(hours)h \(minutes)m"
+            } else {
+                return "Resets in \(minutes)m"
+            }
+        }
+
+        switch resetType {
+        case .hourly: return "Resets every hour"
+        case .daily: return "Resets daily"
+        case .weekly: return "Resets weekly"
+        case .monthly: return "Resets monthly"
+        case .sessionBased: return "Session-based reset"
+        case .manual: return "Manual reset required"
+        case .never: return "No reset"
+        }
+    }
+}
+
+// MARK: - Model/Agent Tracking
+
+/// Tracks which AI model/agent was used
+public struct ModelUsageInfo: Codable, Sendable, Hashable {
+    public let modelName: String
+    public let modelFamily: ModelFamily
+    public let version: String?
+    public let tier: ModelTier
+
+    public enum ModelFamily: String, Codable, Sendable {
+        case gpt4 = "gpt-4"
+        case gpt35 = "gpt-3.5"
+        case claude3 = "claude-3"
+        case claude4 = "claude-4"
+        case gemini = "gemini"
+        case codex = "codex"
+        case other = "other"
+    }
+
+    public enum ModelTier: String, Codable, Sendable {
+        case opus = "opus"          // Highest tier
+        case sonnet = "sonnet"      // Mid tier
+        case haiku = "haiku"        // Fast/cheap tier
+        case turbo = "turbo"
+        case standard = "standard"
+        case unknown = "unknown"
+    }
+
+    public init(
+        modelName: String,
+        modelFamily: ModelFamily = .other,
+        version: String? = nil,
+        tier: ModelTier = .unknown
+    ) {
+        self.modelName = modelName
+        self.modelFamily = modelFamily
+        self.version = version
+        self.tier = tier
+    }
+
+    public var displayName: String {
+        if let version {
+            return "\(modelName) (\(version))"
+        }
+        return modelName
+    }
+}
+
+// MARK: - Project Association
+
+/// Associates usage with a specific project or workspace
+public struct ProjectInfo: Codable, Sendable, Hashable {
+    public let projectID: String
+    public let projectName: String?
+    public let workspacePath: String?
+    public let repository: String?
+    public let tags: [String]
+
+    public init(
+        projectID: String,
+        projectName: String? = nil,
+        workspacePath: String? = nil,
+        repository: String? = nil,
+        tags: [String] = []
+    ) {
+        self.projectID = projectID
+        self.projectName = projectName
+        self.workspacePath = workspacePath
+        self.repository = repository
+        self.tags = tags
+    }
+
+    public var displayName: String {
+        projectName ?? projectID
+    }
+}
+
+// MARK: - Enhanced Usage Snapshot
+
+/// Extended usage snapshot with detailed tracking
+public struct EnhancedUsageSnapshot: Codable, Sendable {
+    // Core usage data (existing)
+    public let provider: UsageProvider
+    public let primary: RateWindow
+    public let secondary: RateWindow?
+    public let tertiary: RateWindow?
+
+    // Account information
+    public let accountType: AccountType
+    public let accountEmail: String?
+    public let accountOrganization: String?
+
+    // Reset tracking
+    public let primaryReset: UsageResetInfo?
+    public let secondaryReset: UsageResetInfo?
+
+    // Model/agent tracking
+    public let recentModels: [ModelUsageInfo]
+    public let primaryModel: ModelUsageInfo?
+
+    // Project tracking
+    public let activeProject: ProjectInfo?
+    public let recentProjects: [ProjectInfo]
+
+    // Session tracking
+    public let sessionID: String?
+    public let sessionStartedAt: Date?
+
+    // Token usage breakdown
+    public let tokenUsage: DetailedTokenUsage?
+
+    // Cost information
+    public let estimatedCost: Double?
+    public let costCurrency: String
+
+    // Metadata
+    public let updatedAt: Date
+    public let fetchSource: String // "oauth", "web", "cli"
+
+    public init(
+        provider: UsageProvider,
+        primary: RateWindow,
+        secondary: RateWindow? = nil,
+        tertiary: RateWindow? = nil,
+        accountType: AccountType = .unknown,
+        accountEmail: String? = nil,
+        accountOrganization: String? = nil,
+        primaryReset: UsageResetInfo? = nil,
+        secondaryReset: UsageResetInfo? = nil,
+        recentModels: [ModelUsageInfo] = [],
+        primaryModel: ModelUsageInfo? = nil,
+        activeProject: ProjectInfo? = nil,
+        recentProjects: [ProjectInfo] = [],
+        sessionID: String? = nil,
+        sessionStartedAt: Date? = nil,
+        tokenUsage: DetailedTokenUsage? = nil,
+        estimatedCost: Double? = nil,
+        costCurrency: String = "USD",
+        updatedAt: Date = Date(),
+        fetchSource: String = "unknown"
+    ) {
+        self.provider = provider
+        self.primary = primary
+        self.secondary = secondary
+        self.tertiary = tertiary
+        self.accountType = accountType
+        self.accountEmail = accountEmail
+        self.accountOrganization = accountOrganization
+        self.primaryReset = primaryReset
+        self.secondaryReset = secondaryReset
+        self.recentModels = recentModels
+        self.primaryModel = primaryModel
+        self.activeProject = activeProject
+        self.recentProjects = recentProjects
+        self.sessionID = sessionID
+        self.sessionStartedAt = sessionStartedAt
+        self.tokenUsage = tokenUsage
+        self.estimatedCost = estimatedCost
+        self.costCurrency = costCurrency
+        self.updatedAt = updatedAt
+        self.fetchSource = fetchSource
+    }
+
+    /// Convert from legacy UsageSnapshot
+    public init(from legacy: UsageSnapshot, provider: UsageProvider) {
+        self.init(
+            provider: provider,
+            primary: legacy.primary,
+            secondary: legacy.secondary,
+            tertiary: legacy.tertiary,
+            accountEmail: legacy.identity?.accountEmail,
+            accountOrganization: legacy.identity?.accountOrganization,
+            updatedAt: legacy.updatedAt
+        )
+    }
+}
+
+// MARK: - Detailed Token Usage
+
+/// Breakdown of token usage by category
+public struct DetailedTokenUsage: Codable, Sendable, Hashable {
+    public let inputTokens: Int
+    public let outputTokens: Int
+    public let cacheCreationTokens: Int
+    public let cacheReadTokens: Int
+    public let totalTokens: Int
+
+    // Per-model breakdown
+    public let modelBreakdown: [String: Int] // modelName -> token count
+
+    // Per-project breakdown
+    public let projectBreakdown: [String: Int] // projectID -> token count
+
+    public init(
+        inputTokens: Int = 0,
+        outputTokens: Int = 0,
+        cacheCreationTokens: Int = 0,
+        cacheReadTokens: Int = 0,
+        modelBreakdown: [String: Int] = [:],
+        projectBreakdown: [String: Int] = [:]
+    ) {
+        self.inputTokens = inputTokens
+        self.outputTokens = outputTokens
+        self.cacheCreationTokens = cacheCreationTokens
+        self.cacheReadTokens = cacheReadTokens
+        self.totalTokens = inputTokens + outputTokens + cacheCreationTokens + cacheReadTokens
+        self.modelBreakdown = modelBreakdown
+        self.projectBreakdown = projectBreakdown
+    }
+}
+
+// MARK: - Usage Alert
+
+/// Proactive alerts for nearing limits
+public struct UsageAlert: Codable, Sendable, Identifiable {
+    public let id: String
+    public let provider: UsageProvider
+    public let severity: Severity
+    public let title: String
+    public let message: String
+    public let threshold: Double // Percentage that triggered alert
+    public let currentUsage: Double
+    public let estimatedTimeToLimit: TimeInterval?
+    public let recommendation: String
+    public let createdAt: Date
+
+    public enum Severity: String, Codable, Sendable {
+        case info = "info"
+        case warning = "warning"
+        case critical = "critical"
+        case urgent = "urgent"
+    }
+
+    public init(
+        id: String = UUID().uuidString,
+        provider: UsageProvider,
+        severity: Severity,
+        title: String,
+        message: String,
+        threshold: Double,
+        currentUsage: Double,
+        estimatedTimeToLimit: TimeInterval? = nil,
+        recommendation: String,
+        createdAt: Date = Date()
+    ) {
+        self.id = id
+        self.provider = provider
+        self.severity = severity
+        self.title = title
+        self.message = message
+        self.threshold = threshold
+        self.currentUsage = currentUsage
+        self.estimatedTimeToLimit = estimatedTimeToLimit
+        self.recommendation = recommendation
+        self.createdAt = createdAt
+    }
+}
+
+// MARK: - Cross-Platform Sync
+
+/// Sync state across devices
+public struct SyncState: Codable, Sendable {
+    public let deviceID: String
+    public let deviceName: String
+    public let platform: Platform
+    public let lastSync: Date
+    public let snapshots: [String: EnhancedUsageSnapshot] // providerID -> snapshot
+
+    public enum Platform: String, Codable, Sendable {
+        case macOS = "macos"
+        case iOS = "ios"
+        case android = "android"
+        case windows = "windows"
+        case cli = "cli"
+    }
+
+    public init(
+        deviceID: String = UUID().uuidString,
+        deviceName: String,
+        platform: Platform,
+        lastSync: Date = Date(),
+        snapshots: [String: EnhancedUsageSnapshot] = [:]
+    ) {
+        self.deviceID = deviceID
+        self.deviceName = deviceName
+        self.platform = platform
+        self.lastSync = lastSync
+        self.snapshots = snapshots
+    }
+}

package/Sources/RunicCore/OpenAIDashboardModels.swift

@@ -0,0 +1,210 @@
+import Foundation
+
+public struct OpenAIDashboardSnapshot: Codable, Equatable, Sendable {
+    public let signedInEmail: String?
+    public let codeReviewRemainingPercent: Double?
+    public let creditEvents: [CreditEvent]
+    public let dailyBreakdown: [OpenAIDashboardDailyBreakdown]
+    /// Usage breakdown time series from the Codex dashboard chart ("Usage breakdown", 30 days).
+    ///
+    /// This is distinct from `dailyBreakdown`, which is derived from `creditEvents` (credits usage history table).
+    public let usageBreakdown: [OpenAIDashboardDailyBreakdown]
+    public let creditsPurchaseURL: String?
+    public let primaryLimit: RateWindow?
+    public let secondaryLimit: RateWindow?
+    public let creditsRemaining: Double?
+    public let accountPlan: String?
+    public let updatedAt: Date
+
+    public init(
+        signedInEmail: String?,
+        codeReviewRemainingPercent: Double?,
+        creditEvents: [CreditEvent],
+        dailyBreakdown: [OpenAIDashboardDailyBreakdown],
+        usageBreakdown: [OpenAIDashboardDailyBreakdown],
+        creditsPurchaseURL: String?,
+        primaryLimit: RateWindow? = nil,
+        secondaryLimit: RateWindow? = nil,
+        creditsRemaining: Double? = nil,
+        accountPlan: String? = nil,
+        updatedAt: Date)
+    {
+        self.signedInEmail = signedInEmail
+        self.codeReviewRemainingPercent = codeReviewRemainingPercent
+        self.creditEvents = creditEvents
+        self.dailyBreakdown = dailyBreakdown
+        self.usageBreakdown = usageBreakdown
+        self.creditsPurchaseURL = creditsPurchaseURL
+        self.primaryLimit = primaryLimit
+        self.secondaryLimit = secondaryLimit
+        self.creditsRemaining = creditsRemaining
+        self.accountPlan = accountPlan
+        self.updatedAt = updatedAt
+    }
+
+    private enum CodingKeys: String, CodingKey {
+        case signedInEmail
+        case codeReviewRemainingPercent
+        case creditEvents
+        case dailyBreakdown
+        case usageBreakdown
+        case creditsPurchaseURL
+        case primaryLimit
+        case secondaryLimit
+        case creditsRemaining
+        case accountPlan
+        case updatedAt
+    }
+
+    public init(from decoder: Decoder) throws {
+        let container = try decoder.container(keyedBy: CodingKeys.self)
+        self.signedInEmail = try container.decodeIfPresent(String.self, forKey: .signedInEmail)
+        self.codeReviewRemainingPercent = try container.decodeIfPresent(
+            Double.self,
+            forKey: .codeReviewRemainingPercent)
+        self.creditEvents = try container.decodeIfPresent([CreditEvent].self, forKey: .creditEvents) ?? []
+        self.dailyBreakdown = try container.decodeIfPresent(
+            [OpenAIDashboardDailyBreakdown].self,
+            forKey: .dailyBreakdown)
+            ?? Self.makeDailyBreakdown(from: self.creditEvents, maxDays: 30)
+        self.usageBreakdown = try container.decodeIfPresent(
+            [OpenAIDashboardDailyBreakdown].self,
+            forKey: .usageBreakdown) ?? []
+        self.creditsPurchaseURL = try container.decodeIfPresent(String.self, forKey: .creditsPurchaseURL)
+        self.primaryLimit = try container.decodeIfPresent(RateWindow.self, forKey: .primaryLimit)
+        self.secondaryLimit = try container.decodeIfPresent(RateWindow.self, forKey: .secondaryLimit)
+        self.creditsRemaining = try container.decodeIfPresent(Double.self, forKey: .creditsRemaining)
+        self.accountPlan = try container.decodeIfPresent(String.self, forKey: .accountPlan)
+        self.updatedAt = try container.decode(Date.self, forKey: .updatedAt)
+    }
+
+    public static func makeDailyBreakdown(from events: [CreditEvent], maxDays: Int) -> [OpenAIDashboardDailyBreakdown] {
+        guard !events.isEmpty else { return [] }
+
+        let calendar = Calendar(identifier: .gregorian)
+        let formatter = DateFormatter()
+        formatter.locale = Locale(identifier: "en_US_POSIX")
+        formatter.calendar = calendar
+        formatter.timeZone = TimeZone.current
+        formatter.dateFormat = "yyyy-MM-dd"
+
+        var totals: [String: [String: Double]] = [:] // day -> service -> credits
+        for event in events {
+            let day = formatter.string(from: event.date)
+            totals[day, default: [:]][event.service, default: 0] += event.creditsUsed
+        }
+
+        let sortedDays = totals.keys.sorted(by: >).prefix(maxDays)
+        return sortedDays.map { day in
+            let serviceTotals = totals[day] ?? [:]
+            let services = serviceTotals
+                .map { OpenAIDashboardServiceUsage(service: $0.key, creditsUsed: $0.value) }
+                .sorted { lhs, rhs in
+                    if lhs.creditsUsed == rhs.creditsUsed { return lhs.service < rhs.service }
+                    return lhs.creditsUsed > rhs.creditsUsed
+                }
+            let total = services.reduce(0) { $0 + $1.creditsUsed }
+            return OpenAIDashboardDailyBreakdown(day: day, services: services, totalCreditsUsed: total)
+        }
+    }
+}
+
+extension OpenAIDashboardSnapshot {
+    public func toUsageSnapshot(
+        provider: UsageProvider = .codex,
+        accountEmail: String? = nil,
+        accountPlan: String? = nil) -> UsageSnapshot?
+    {
+        guard let primaryLimit else { return nil }
+        let resolvedEmail = accountEmail ?? self.signedInEmail
+        let resolvedPlan = accountPlan ?? self.accountPlan
+        let identity = ProviderIdentitySnapshot(
+            providerID: provider,
+            accountEmail: resolvedEmail,
+            accountOrganization: nil,
+            loginMethod: resolvedPlan)
+        return UsageSnapshot(
+            primary: primaryLimit,
+            secondary: self.secondaryLimit,
+            tertiary: nil,
+            providerCost: nil,
+            updatedAt: self.updatedAt,
+            identity: identity)
+    }
+
+    public func toCreditsSnapshot() -> CreditsSnapshot? {
+        guard let creditsRemaining else { return nil }
+        return CreditsSnapshot(remaining: creditsRemaining, events: self.creditEvents, updatedAt: self.updatedAt)
+    }
+}
+
+public struct OpenAIDashboardDailyBreakdown: Codable, Equatable, Sendable {
+    /// Day key in `yyyy-MM-dd` (local time).
+    public let day: String
+    public let services: [OpenAIDashboardServiceUsage]
+    public let totalCreditsUsed: Double
+
+    public init(day: String, services: [OpenAIDashboardServiceUsage], totalCreditsUsed: Double) {
+        self.day = day
+        self.services = services
+        self.totalCreditsUsed = totalCreditsUsed
+    }
+}
+
+public struct OpenAIDashboardServiceUsage: Codable, Equatable, Sendable {
+    public let service: String
+    public let creditsUsed: Double
+
+    public init(service: String, creditsUsed: Double) {
+        self.service = service
+        self.creditsUsed = creditsUsed
+    }
+}
+
+public struct OpenAIDashboardCache: Codable, Equatable, Sendable {
+    public let accountEmail: String
+    public let snapshot: OpenAIDashboardSnapshot
+
+    public init(accountEmail: String, snapshot: OpenAIDashboardSnapshot) {
+        self.accountEmail = accountEmail
+        self.snapshot = snapshot
+    }
+}
+
+public enum OpenAIDashboardCacheStore {
+    public static func load() -> OpenAIDashboardCache? {
+        guard let url = self.cacheURL else { return nil }
+        guard let data = try? Data(contentsOf: url) else { return nil }
+        let decoder = JSONDecoder()
+        decoder.dateDecodingStrategy = .iso8601
+        return try? decoder.decode(OpenAIDashboardCache.self, from: data)
+    }
+
+    public static func save(_ cache: OpenAIDashboardCache) {
+        guard let url = self.cacheURL else { return }
+        do {
+            try FileManager.default.createDirectory(
+                at: url.deletingLastPathComponent(),
+                withIntermediateDirectories: true)
+            let encoder = JSONEncoder()
+            encoder.dateEncodingStrategy = .iso8601
+            let data = try encoder.encode(cache)
+            try data.write(to: url, options: [.atomic])
+        } catch {
+            // Best-effort cache only; ignore errors.
+        }
+    }
+
+    public static func clear() {
+        guard let url = self.cacheURL else { return }
+        try? FileManager.default.removeItem(at: url)
+    }
+
+    private static var cacheURL: URL? {
+        guard let root = FileManager.default.urls(for: .applicationSupportDirectory, in: .userDomainMask).first else {
+            return nil
+        }
+        let dir = root.appendingPathComponent("com.sriinnu.athena.runic", isDirectory: true)
+        return dir.appendingPathComponent("openai-dashboard.json")
+    }
+}