@sriinnu/runic 1.0.0

package/Sources/RunicCore/Providers/ProviderDescriptor.swift

@@ -0,0 +1,129 @@
+import Foundation
+import RunicMacroSupport
+
+public struct ProviderTokenCostConfig: Sendable {
+    public let supportsTokenCost: Bool
+    public let noDataMessage: @Sendable () -> String
+
+    public init(supportsTokenCost: Bool, noDataMessage: @escaping @Sendable () -> String) {
+        self.supportsTokenCost = supportsTokenCost
+        self.noDataMessage = noDataMessage
+    }
+}
+
+public struct ProviderDescriptor: Sendable {
+    public let id: UsageProvider
+    public let metadata: ProviderMetadata
+    public let branding: ProviderBranding
+    public let tokenCost: ProviderTokenCostConfig
+    public let fetchPlan: ProviderFetchPlan
+    public let cli: ProviderCLIConfig
+
+    public init(
+        id: UsageProvider,
+        metadata: ProviderMetadata,
+        branding: ProviderBranding,
+        tokenCost: ProviderTokenCostConfig,
+        fetchPlan: ProviderFetchPlan,
+        cli: ProviderCLIConfig)
+    {
+        self.id = id
+        self.metadata = metadata
+        self.branding = branding
+        self.tokenCost = tokenCost
+        self.fetchPlan = fetchPlan
+        self.cli = cli
+    }
+
+    public func fetchOutcome(context: ProviderFetchContext) async -> ProviderFetchOutcome {
+        await self.fetchPlan.fetchOutcome(context: context, provider: self.id)
+    }
+
+    public func fetch(context: ProviderFetchContext) async throws -> ProviderFetchResult {
+        let outcome = await self.fetchOutcome(context: context)
+        return try outcome.result.get()
+    }
+}
+
+public enum ProviderDescriptorRegistry {
+    private final class Store: @unchecked Sendable {
+        var ordered: [ProviderDescriptor] = []
+        var byID: [UsageProvider: ProviderDescriptor] = [:]
+    }
+
+    private static let lock = NSLock()
+    private static let store = Store()
+    private static let bootstrap: Void = {
+        _ = ProviderDescriptorRegistry.register(CodexProviderDescriptor.descriptor)
+        _ = ProviderDescriptorRegistry.register(ClaudeProviderDescriptor.descriptor)
+        _ = ProviderDescriptorRegistry.register(FactoryProviderDescriptor.descriptor)
+        _ = ProviderDescriptorRegistry.register(ZaiProviderDescriptor.descriptor)
+        _ = ProviderDescriptorRegistry.register(CursorProviderDescriptor.descriptor)
+        _ = ProviderDescriptorRegistry.register(GeminiProviderDescriptor.descriptor)
+        _ = ProviderDescriptorRegistry.register(AntigravityProviderDescriptor.descriptor)
+        _ = ProviderDescriptorRegistry.register(CopilotProviderDescriptor.descriptor)
+        _ = ProviderDescriptorRegistry.register(MiniMaxProviderDescriptor.descriptor)
+        _ = ProviderDescriptorRegistry.register(OpenRouterProviderDescriptor.descriptor)
+        _ = ProviderDescriptorRegistry.register(GroqProviderDescriptor.descriptor)
+        _ = ProviderDescriptorRegistry.register(DeepSeekProviderDescriptor.descriptor)
+        _ = ProviderDescriptorRegistry.register(FireworksProviderDescriptor.descriptor)
+        _ = ProviderDescriptorRegistry.register(MistralProviderDescriptor.descriptor)
+        _ = ProviderDescriptorRegistry.register(PerplexityProviderDescriptor.descriptor)
+        _ = ProviderDescriptorRegistry.register(KimiProviderDescriptor.descriptor)
+        _ = ProviderDescriptorRegistry.register(AuggieProviderDescriptor.descriptor)
+        _ = ProviderDescriptorRegistry.register(TogetherProviderDescriptor.descriptor)
+        _ = ProviderDescriptorRegistry.register(CohereProviderDescriptor.descriptor)
+        _ = ProviderDescriptorRegistry.register(XAIProviderDescriptor.descriptor)
+        _ = ProviderDescriptorRegistry.register(CerebrasProviderDescriptor.descriptor)
+        _ = ProviderDescriptorRegistry.register(SambaNovaProviderDescriptor.descriptor)
+        _ = ProviderDescriptorRegistry.register(AzureProviderDescriptor.descriptor)
+        _ = ProviderDescriptorRegistry.register(BedrockProviderDescriptor.descriptor)
+        _ = ProviderDescriptorRegistry.register(VertexAIProviderDescriptor.descriptor)
+        _ = ProviderDescriptorRegistry.register(QwenProviderDescriptor.descriptor)
+    }()
+
+    private static func ensureBootstrapped() {
+        _ = self.bootstrap
+    }
+
+    @discardableResult
+    public static func register(_ descriptor: ProviderDescriptor) -> ProviderDescriptor {
+        self.lock.lock()
+        defer { self.lock.unlock() }
+        if self.store.byID[descriptor.id] == nil {
+            self.store.ordered.append(descriptor)
+        }
+        self.store.byID[descriptor.id] = descriptor
+        return descriptor
+    }
+
+    public static var all: [ProviderDescriptor] {
+        self.ensureBootstrapped()
+        self.lock.lock()
+        defer { self.lock.unlock() }
+        return self.store.ordered
+    }
+
+    public static var metadata: [UsageProvider: ProviderMetadata] {
+        Dictionary(uniqueKeysWithValues: self.all.map { ($0.id, $0.metadata) })
+    }
+
+    public static func descriptor(for id: UsageProvider) -> ProviderDescriptor {
+        self.ensureBootstrapped()
+        if let found = self.store.byID[id] { return found }
+        if let found = self.all.first(where: { $0.id == id }) { return found }
+        fatalError("Missing ProviderDescriptor for \(id.rawValue)")
+    }
+
+    public static var cliNameMap: [String: UsageProvider] {
+        self.ensureBootstrapped()
+        var map: [String: UsageProvider] = [:]
+        for descriptor in self.all {
+            map[descriptor.cli.name] = descriptor.id
+            for alias in descriptor.cli.aliases {
+                map[alias] = descriptor.id
+            }
+        }
+        return map
+    }
+}

package/Sources/RunicCore/Providers/ProviderFetchPlan.swift

@@ -0,0 +1,263 @@
+import Foundation
+
+public enum ProviderRuntime: Sendable {
+    case app
+    case cli
+}
+
+public enum ProviderSourceMode: String, CaseIterable, Sendable {
+    case auto
+    case web
+    case api
+    case cli
+    case oauth
+
+    public var usesWeb: Bool {
+        self == .auto || self == .web
+    }
+}
+
+public struct ProviderFetchContext: Sendable {
+    public let runtime: ProviderRuntime
+    public let sourceMode: ProviderSourceMode
+    public let includeCredits: Bool
+    public let webTimeout: TimeInterval
+    public let webDebugDumpHTML: Bool
+    public let verbose: Bool
+    public let env: [String: String]
+    public let settings: ProviderSettingsSnapshot?
+    public let fetcher: UsageFetcher
+    public let claudeFetcher: any ClaudeUsageFetching
+
+    public init(
+        runtime: ProviderRuntime,
+        sourceMode: ProviderSourceMode,
+        includeCredits: Bool,
+        webTimeout: TimeInterval,
+        webDebugDumpHTML: Bool,
+        verbose: Bool,
+        env: [String: String],
+        settings: ProviderSettingsSnapshot?,
+        fetcher: UsageFetcher,
+        claudeFetcher: any ClaudeUsageFetching)
+    {
+        self.runtime = runtime
+        self.sourceMode = sourceMode
+        self.includeCredits = includeCredits
+        self.webTimeout = webTimeout
+        self.webDebugDumpHTML = webDebugDumpHTML
+        self.verbose = verbose
+        self.env = env
+        self.settings = settings
+        self.fetcher = fetcher
+        self.claudeFetcher = claudeFetcher
+    }
+}
+
+public struct ProviderFetchResult: Sendable {
+    public let usage: UsageSnapshot
+    public let credits: CreditsSnapshot?
+    public let dashboard: OpenAIDashboardSnapshot?
+    public let sourceLabel: String
+    public let strategyID: String
+    public let strategyKind: ProviderFetchKind
+
+    public init(
+        usage: UsageSnapshot,
+        credits: CreditsSnapshot?,
+        dashboard: OpenAIDashboardSnapshot?,
+        sourceLabel: String,
+        strategyID: String,
+        strategyKind: ProviderFetchKind)
+    {
+        self.usage = usage
+        self.credits = credits
+        self.dashboard = dashboard
+        self.sourceLabel = sourceLabel
+        self.strategyID = strategyID
+        self.strategyKind = strategyKind
+    }
+}
+
+public struct ProviderFetchAttempt: Sendable {
+    public let strategyID: String
+    public let kind: ProviderFetchKind
+    public let wasAvailable: Bool
+    public let errorDescription: String?
+
+    public init(strategyID: String, kind: ProviderFetchKind, wasAvailable: Bool, errorDescription: String?) {
+        self.strategyID = strategyID
+        self.kind = kind
+        self.wasAvailable = wasAvailable
+        self.errorDescription = errorDescription
+    }
+}
+
+public struct ProviderFetchOutcome: @unchecked Sendable {
+    public let result: Result<ProviderFetchResult, Error>
+    public let attempts: [ProviderFetchAttempt]
+
+    public init(result: Result<ProviderFetchResult, Error>, attempts: [ProviderFetchAttempt]) {
+        self.result = result
+        self.attempts = attempts
+    }
+}
+
+public enum ProviderFetchError: LocalizedError, Sendable {
+    case noAvailableStrategy(UsageProvider)
+    case missingCredentials
+    case strategyTimeout(
+        provider: UsageProvider,
+        strategyID: String,
+        timeoutSeconds: TimeInterval)
+
+    public var errorDescription: String? {
+        switch self {
+        case let .noAvailableStrategy(provider):
+            if provider == .copilot {
+                return "No available fetch strategy for copilot. Add `COPILOT_API_TOKEN`, `GITHUB_TOKEN`, or `GH_TOKEN`, " +
+                    "or configure GitHub CLI (`GH_CONFIG_DIR` / `~/.config/gh`). " +
+                    "You can also sign in from Runic Copilot settings or keep VS Code signed in with accessible keychain secrets."
+            }
+            return "No available fetch strategy for \(provider.rawValue)."
+        case .missingCredentials:
+            return "Missing or invalid credentials."
+        case let .strategyTimeout(provider, strategyID, timeoutSeconds):
+            return "Fetch strategy \(strategyID) for \(provider.rawValue) timed out after " +
+                "\(String(format: "%.1f", timeoutSeconds))s."
+        }
+    }
+}
+
+public enum ProviderFetchKind: Sendable {
+    case cli
+    case api
+    case web
+    case oauth
+    case apiToken
+    case localProbe
+    case webDashboard
+}
+
+public protocol ProviderFetchStrategy: Sendable {
+    var id: String { get }
+    var kind: ProviderFetchKind { get }
+    func isAvailable(_ context: ProviderFetchContext) async -> Bool
+    func fetch(_ context: ProviderFetchContext) async throws -> ProviderFetchResult
+    func shouldFallback(on error: Error, context: ProviderFetchContext) -> Bool
+}
+
+extension ProviderFetchStrategy {
+    public func makeResult(
+        usage: UsageSnapshot,
+        credits: CreditsSnapshot? = nil,
+        dashboard: OpenAIDashboardSnapshot? = nil,
+        sourceLabel: String) -> ProviderFetchResult
+    {
+        ProviderFetchResult(
+            usage: usage,
+            credits: credits,
+            dashboard: dashboard,
+            sourceLabel: sourceLabel,
+            strategyID: self.id,
+            strategyKind: self.kind)
+    }
+}
+
+public struct ProviderFetchPipeline: Sendable {
+    public let resolveStrategies: @Sendable (ProviderFetchContext) async -> [any ProviderFetchStrategy]
+    public let strategyTimeout: TimeInterval
+
+    public init(
+        resolveStrategies: @escaping @Sendable (ProviderFetchContext) async -> [any ProviderFetchStrategy],
+        strategyTimeout: TimeInterval = 45
+    ) {
+        self.resolveStrategies = resolveStrategies
+        self.strategyTimeout = strategyTimeout
+    }
+
+    public func fetch(context: ProviderFetchContext, provider: UsageProvider) async -> ProviderFetchOutcome {
+        let strategies = await self.resolveStrategies(context)
+        var attempts: [ProviderFetchAttempt] = []
+        attempts.reserveCapacity(strategies.count)
+
+        for strategy in strategies {
+            let available = await strategy.isAvailable(context)
+            guard available else {
+                attempts.append(ProviderFetchAttempt(
+                    strategyID: strategy.id,
+                    kind: strategy.kind,
+                    wasAvailable: false,
+                    errorDescription: nil))
+                continue
+            }
+
+            do {
+                let result = try await self.fetchWithTimeout(
+                    strategy: strategy,
+                    context: context,
+                    provider: provider)
+                attempts.append(ProviderFetchAttempt(
+                    strategyID: strategy.id,
+                    kind: strategy.kind,
+                    wasAvailable: true,
+                    errorDescription: nil))
+                return ProviderFetchOutcome(result: .success(result), attempts: attempts)
+            } catch {
+                attempts.append(ProviderFetchAttempt(
+                    strategyID: strategy.id,
+                    kind: strategy.kind,
+                    wasAvailable: true,
+                    errorDescription: error.localizedDescription))
+                if strategy.shouldFallback(on: error, context: context) {
+                    continue
+                }
+                return ProviderFetchOutcome(result: .failure(error), attempts: attempts)
+            }
+        }
+
+        let error = ProviderFetchError.noAvailableStrategy(provider)
+        return ProviderFetchOutcome(result: .failure(error), attempts: attempts)
+    }
+
+    private func fetchWithTimeout(
+        strategy: any ProviderFetchStrategy,
+        context: ProviderFetchContext,
+        provider: UsageProvider) async throws -> ProviderFetchResult
+    {
+        try await withThrowingTaskGroup(of: ProviderFetchResult.self) { group in
+            group.addTask {
+                try await strategy.fetch(context)
+            }
+
+            group.addTask {
+                try await Task.sleep(for: .seconds(self.strategyTimeout))
+                throw ProviderFetchError.strategyTimeout(
+                    provider: provider,
+                    strategyID: strategy.id,
+                    timeoutSeconds: self.strategyTimeout)
+            }
+
+            defer { group.cancelAll() }
+
+            guard let result = try await group.next() else {
+                throw CancellationError()
+            }
+            return result
+        }
+    }
+}
+
+public struct ProviderFetchPlan: Sendable {
+    public let sourceModes: Set<ProviderSourceMode>
+    public let pipeline: ProviderFetchPipeline
+
+    public init(sourceModes: Set<ProviderSourceMode>, pipeline: ProviderFetchPipeline) {
+        self.sourceModes = sourceModes
+        self.pipeline = pipeline
+    }
+
+    public func fetchOutcome(context: ProviderFetchContext, provider: UsageProvider) async -> ProviderFetchOutcome {
+        await self.pipeline.fetch(context: context, provider: provider)
+    }
+}

package/Sources/RunicCore/Providers/ProviderSettingsSnapshot.swift

@@ -0,0 +1,98 @@
+import Foundation
+
+public struct ProviderSettingsSnapshot: Sendable {
+    public struct CodexProviderSettings: Sendable {
+        public let usageDataSource: CodexUsageDataSource
+
+        public init(usageDataSource: CodexUsageDataSource) {
+            self.usageDataSource = usageDataSource
+        }
+    }
+
+    public struct ClaudeProviderSettings: Sendable {
+        public let usageDataSource: ClaudeUsageDataSource
+        public let webExtrasEnabled: Bool
+
+        public init(usageDataSource: ClaudeUsageDataSource, webExtrasEnabled: Bool) {
+            self.usageDataSource = usageDataSource
+            self.webExtrasEnabled = webExtrasEnabled
+        }
+    }
+
+    public struct ZaiProviderSettings: Sendable {
+        public init() {}
+    }
+
+    public struct CopilotProviderSettings: Sendable {
+        public let apiToken: String?
+
+        public init(apiToken: String?) {
+            self.apiToken = apiToken
+        }
+    }
+
+    public struct AzureProviderSettings: Sendable {
+        public let apiToken: String?
+        public let endpoint: String?
+        public let deployment: String?
+        public let apiVersion: String?
+
+        public init(apiToken: String?, endpoint: String?, deployment: String?, apiVersion: String?) {
+            self.apiToken = apiToken
+            self.endpoint = endpoint
+            self.deployment = deployment
+            self.apiVersion = apiVersion
+        }
+    }
+
+    public struct BedrockProviderSettings: Sendable {
+        public let region: String?
+        public let profile: String?
+        public let modelID: String?
+
+        public init(region: String?, profile: String?, modelID: String?) {
+            self.region = region
+            self.profile = profile
+            self.modelID = modelID
+        }
+    }
+
+    public struct VertexAIProviderSettings: Sendable {
+        public let project: String?
+        public let location: String?
+
+        public init(project: String?, location: String?) {
+            self.project = project
+            self.location = location
+        }
+    }
+
+    public let debugMenuEnabled: Bool
+    public let codex: CodexProviderSettings?
+    public let claude: ClaudeProviderSettings?
+    public let zai: ZaiProviderSettings?
+    public let copilot: CopilotProviderSettings?
+    public let azure: AzureProviderSettings?
+    public let bedrock: BedrockProviderSettings?
+    public let vertexai: VertexAIProviderSettings?
+
+    public init(
+        debugMenuEnabled: Bool,
+        codex: CodexProviderSettings?,
+        claude: ClaudeProviderSettings?,
+        zai: ZaiProviderSettings?,
+        copilot: CopilotProviderSettings?,
+        azure: AzureProviderSettings?,
+        bedrock: BedrockProviderSettings?,
+        vertexai: VertexAIProviderSettings? = nil)
+    {
+        self.debugMenuEnabled = debugMenuEnabled
+        self.codex = codex
+        self.claude = claude
+        self.zai = zai
+        self.copilot = copilot
+        self.azure = azure
+        self.bedrock = bedrock
+        self.vertexai = vertexai
+    }
+}