@sriinnu/runic 1.2.0 → 2.11.1

package/Sources/RunicCore/Providers/ProviderDescriptor.swift

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

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

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