@sriinnu/runic 2.0.0 → 2.11.2

package/Tests/RunicTests/OTelGenAILedgerAdapterTests.swift

@@ -1,110 +0,0 @@
-import Foundation
-import Testing
-@testable import RunicCore
-
-struct OTelGenAILedgerAdapterTests {
-    @Test
-    func `parses flat gen AI payload into ledger entry`() throws {
-        let payload = """
-        {
-          "timestamp": "2026-02-23T12:00:00Z",
-          "attributes": {
-            "gen_ai.system": "anthropic",
-            "gen_ai.request.model": "claude-3-5-sonnet",
-            "gen_ai.usage.input_tokens": 120,
-            "gen_ai.usage.output_tokens": "80",
-            "project.id": "proj-alpha",
-            "project.name": "Alpha",
-            "gen_ai.conversation.id": "session-1",
-            "gen_ai.request.id": "request-1",
-            "gen_ai.usage.cost": 0.42
-          }
-        }
-        """
-        let options = OTelGenAIIngestionOptions(enabled: true)
-        let entries = try OTelGenAILedgerAdapter.parseData(Data(payload.utf8), options: options)
-
-        #expect(entries.count == 1)
-        let entry = try #require(entries.first)
-        #expect(entry.provider == .claude)
-        #expect(entry.model == "claude-3-5-sonnet")
-        #expect(entry.inputTokens == 120)
-        #expect(entry.outputTokens == 80)
-        #expect(entry.projectID == "proj-alpha")
-        #expect(entry.projectName == "Alpha")
-        #expect(entry.sessionID == "session-1")
-        #expect(entry.requestID == "request-1")
-        #expect(abs((entry.costUSD ?? 0) - 0.42) < 0.000_001)
-    }
-
-    @Test
-    func `parses OTLP resource spans payload`() throws {
-        let payload = """
-        {
-          "resourceSpans": [
-            {
-              "resource": {
-                "attributes": [
-                  { "key": "project.name", "value": { "stringValue": "Telemetry Project" } }
-                ]
-              },
-              "scopeSpans": [
-                {
-                  "spans": [
-                    {
-                      "name": "chat.completion",
-                      "endTimeUnixNano": "1771828800000000000",
-                      "attributes": [
-                        { "key": "gen_ai.system", "value": { "stringValue": "openai" } },
-                        { "key": "gen_ai.request.model", "value": { "stringValue": "gpt-5" } },
-                        { "key": "gen_ai.usage.input_tokens", "value": { "intValue": "200" } },
-                        { "key": "gen_ai.usage.output_tokens", "value": { "doubleValue": 50.0 } },
-                        { "key": "project.id", "value": { "stringValue": "proj-otlp" } }
-                      ]
-                    }
-                  ]
-                }
-              ]
-            }
-          ]
-        }
-        """
-        let entries = try OTelGenAILedgerAdapter.parseData(
-            Data(payload.utf8),
-            options: OTelGenAIIngestionOptions(enabled: true))
-
-        #expect(entries.count == 1)
-        let entry = try #require(entries.first)
-        #expect(entry.provider == .codex)
-        #expect(entry.model == "gpt-5")
-        #expect(entry.inputTokens == 200)
-        #expect(entry.outputTokens == 50)
-        #expect(entry.projectID == "proj-otlp")
-        #expect(entry.projectName == "Telemetry Project")
-    }
-
-    @Test
-    func `feature flag disables ingestion`() throws {
-        let payload = """
-        {"attributes":{"gen_ai.system":"openai","gen_ai.request.model":"gpt-5","gen_ai.usage.input_tokens":1}}
-        """
-        let entries = try OTelGenAILedgerAdapter.parseData(
-            Data(payload.utf8),
-            options: OTelGenAIIngestionOptions(enabled: false))
-        #expect(entries.isEmpty)
-    }
-
-    @Test
-    func `default provider backfills unknown provider`() throws {
-        let payload = """
-        {"attributes":{"gen_ai.request.model":"custom-model-v1","gen_ai.usage.input_tokens":9}}
-        """
-        let entries = try OTelGenAILedgerAdapter.parseData(
-            Data(payload.utf8),
-            options: OTelGenAIIngestionOptions(enabled: true, defaultProvider: .openrouter))
-
-        #expect(entries.count == 1)
-        #expect(entries.first?.provider == .openrouter)
-        #expect(entries.first?.model == "custom-model-v1")
-    }
-}

package/Tests/RunicTests/OpenAIDashboardBrowserCookieImporterTests.swift

@@ -1,16 +0,0 @@
-import RunicCore
-import Testing
-
-struct OpenAIDashboardBrowserCookieImporterTests {
-    @Test
-    func `mismatch error mentions source label`() {
-        let err = OpenAIDashboardBrowserCookieImporter.ImportError.noMatchingAccount(
-            found: [
-                .init(sourceLabel: "Safari", email: "a@example.com"),
-                .init(sourceLabel: "Chrome", email: "b@example.com"),
-            ])
-        let msg = err.localizedDescription
-        #expect(msg.contains("Safari=a@example.com"))
-        #expect(msg.contains("Chrome=b@example.com"))
-    }
-}

package/Tests/RunicTests/OpenAIDashboardFetcherCreditsWaitTests.swift

@@ -1,74 +0,0 @@
-import Foundation
-import Testing
-@testable import RunicCore
-
-struct OpenAIDashboardFetcherCreditsWaitTests {
-    @Test
-    func `waits after scroll request`() {
-        let now = Date()
-        let shouldWait = OpenAIDashboardFetcher.shouldWaitForCreditsHistory(.init(
-            now: now,
-            anyDashboardSignalAt: now.addingTimeInterval(-10),
-            creditsHeaderVisibleAt: nil,
-            creditsHeaderPresent: false,
-            creditsHeaderInViewport: false,
-            didScrollToCredits: true))
-        #expect(shouldWait == true)
-    }
-
-    @Test
-    func `waits briefly when header visible but table empty`() {
-        let now = Date()
-        let visibleAt = now.addingTimeInterval(-1.0)
-        let shouldWait = OpenAIDashboardFetcher.shouldWaitForCreditsHistory(.init(
-            now: now,
-            anyDashboardSignalAt: now.addingTimeInterval(-10),
-            creditsHeaderVisibleAt: visibleAt,
-            creditsHeaderPresent: true,
-            creditsHeaderInViewport: true,
-            didScrollToCredits: false))
-        #expect(shouldWait == true)
-    }
-
-    @Test
-    func `stops waiting after header has been visible long enough`() {
-        let now = Date()
-        let visibleAt = now.addingTimeInterval(-3.0)
-        let shouldWait = OpenAIDashboardFetcher.shouldWaitForCreditsHistory(.init(
-            now: now,
-            anyDashboardSignalAt: now.addingTimeInterval(-10),
-            creditsHeaderVisibleAt: visibleAt,
-            creditsHeaderPresent: true,
-            creditsHeaderInViewport: true,
-            didScrollToCredits: false))
-        #expect(shouldWait == false)
-    }
-
-    @Test
-    func `waits briefly after first dashboard signal even when header not present yet`() {
-        let now = Date()
-        let startedAt = now.addingTimeInterval(-2.0)
-        let shouldWait = OpenAIDashboardFetcher.shouldWaitForCreditsHistory(.init(
-            now: now,
-            anyDashboardSignalAt: startedAt,
-            creditsHeaderVisibleAt: nil,
-            creditsHeaderPresent: false,
-            creditsHeaderInViewport: false,
-            didScrollToCredits: false))
-        #expect(shouldWait == true)
-    }
-
-    @Test
-    func `stops waiting eventually when header never appears`() {
-        let now = Date()
-        let startedAt = now.addingTimeInterval(-7.0)
-        let shouldWait = OpenAIDashboardFetcher.shouldWaitForCreditsHistory(.init(
-            now: now,
-            anyDashboardSignalAt: startedAt,
-            creditsHeaderVisibleAt: nil,
-            creditsHeaderPresent: false,
-            creditsHeaderInViewport: false,
-            didScrollToCredits: false))
-        #expect(shouldWait == false)
-    }
-}

package/Tests/RunicTests/OpenAIDashboardOffscreenHostTests.swift

@@ -1,26 +0,0 @@
-import Foundation
-import Testing
-@testable import RunicCore
-
-struct OpenAIDashboardOffscreenHostTests {
-    @Test
-    func `offscreen host frame only intersects by A sliver`() {
-        let visibleFrame = CGRect(x: 0, y: 0, width: 1000, height: 800)
-        let frame = OpenAIDashboardFetcher.offscreenHostWindowFrame(for: visibleFrame)
-        let intersection = frame.intersection(visibleFrame)
-
-        #expect(frame.size.width == visibleFrame.size.width)
-        #expect(frame.size.height == visibleFrame.size.height)
-        #expect(intersection.size.width <= 1.0)
-        #expect(intersection.size.height <= 1.0)
-        #expect(intersection.minX >= visibleFrame.maxX - 1.0)
-        #expect(intersection.minY >= visibleFrame.maxY - 1.0)
-    }
-
-    @Test
-    func `offscreen host alpha value is non zero but tiny`() {
-        let alpha = OpenAIDashboardFetcher.offscreenHostAlphaValue()
-        #expect(alpha > 0)
-        #expect(alpha <= 0.001)
-    }
-}

package/Tests/RunicTests/OpenAIDashboardParserTests.swift

@@ -1,133 +0,0 @@
-import Foundation
-import RunicCore
-import Testing
-@testable import Runic
-
-struct OpenAIDashboardParserTests {
-    @Test
-    func `parses signed in email from client bootstrap HTML`() {
-        let html = """
-        <html>
-        <head></head>
-        <body>
-        <script type="application/json" id="client-bootstrap">
-        {"authStatus":"logged_in","session":{"user":{"email":"studpete@gmail.com"}}}
-        </script>
-        </body>
-        </html>
-        """
-        #expect(OpenAIDashboardParser.parseSignedInEmailFromClientBootstrap(html: html) == "studpete@gmail.com")
-        #expect(OpenAIDashboardParser.parseAuthStatusFromClientBootstrap(html: html) == "logged_in")
-    }
-
-    @Test
-    func `parses code review remaining percent inline`() {
-        let body = "Balance\nCode review 42% remaining\nCredits remaining 291"
-        #expect(OpenAIDashboardParser.parseCodeReviewRemainingPercent(bodyText: body) == 42)
-    }
-
-    @Test
-    func `parses code review remaining percent multiline`() {
-        let body = "Balance\nCode review\n100% remaining\nWeekly usage limit\n0% remaining"
-        #expect(OpenAIDashboardParser.parseCodeReviewRemainingPercent(bodyText: body) == 100)
-    }
-
-    @Test
-    func `parses credits remaining`() {
-        let body = "Balance\nCredits remaining 1,234.56\nUsage"
-        let value = OpenAIDashboardParser.parseCreditsRemaining(bodyText: body)
-        #expect(abs((value ?? 0) - 1234.56) < 0.001)
-    }
-
-    @Test
-    func `parses rate limits`() {
-        let body = """
-        Usage limits
-        5h limit
-        72% remaining
-        Resets today at 2:15 PM
-        Weekly limit
-        41% remaining
-        Resets Fri at 9:00 AM
-        """
-        let limits = OpenAIDashboardParser.parseRateLimits(bodyText: body)
-        #expect(abs((limits.primary?.usedPercent ?? 0) - 28) < 0.001)
-        #expect(limits.primary?.windowMinutes == 300)
-        #expect(limits.primary?.resetDescription?.lowercased().contains("resets") == true)
-        #expect(abs((limits.secondary?.usedPercent ?? 0) - 59) < 0.001)
-        #expect(limits.secondary?.windowMinutes == 10080)
-    }
-
-    @Test
-    func `parses plan from client bootstrap`() {
-        let html = """
-        <html>
-        <body>
-        <script type="application/json" id="client-bootstrap">
-        {"session":{"user":{"email":"user@example.com"}},"planType":"plus"}
-        </script>
-        </body>
-        </html>
-        """
-        #expect(OpenAIDashboardParser.parsePlanFromHTML(html: html) == "Plus")
-    }
-
-    @Test
-    func `parses credit events from table rows`() {
-        let rows: [[String]] = [
-            ["Dec 18, 2025", "CLI", "397.205 credits"],
-            ["Dec 17, 2025", "GitHub Code Review", "506.235 credits"],
-        ]
-        let events = OpenAIDashboardParser.parseCreditEvents(rows: rows)
-        #expect(events.count == 2)
-        #expect(events.first?.service == "CLI")
-        #expect(abs((events.first?.creditsUsed ?? 0) - 397.205) < 0.0001)
-        #expect(events.last?.service == "GitHub Code Review")
-        #expect(abs((events.last?.creditsUsed ?? 0) - 506.235) < 0.0001)
-    }
-
-    @Test
-    func `builds daily breakdown from events`() throws {
-        let calendar = Calendar(identifier: .gregorian)
-        var components = DateComponents()
-        components.calendar = calendar
-        components.timeZone = TimeZone(secondsFromGMT: 0)
-
-        components.year = 2025
-        components.month = 12
-        components.day = 18
-        let dec18 = try #require(components.date)
-
-        components.day = 17
-        let dec17 = try #require(components.date)
-
-        let events = [
-            CreditEvent(date: dec18, service: "CLI", creditsUsed: 10),
-            CreditEvent(date: dec18, service: "CLI", creditsUsed: 5),
-            CreditEvent(date: dec18, service: "GitHub Code Review", creditsUsed: 2),
-            CreditEvent(date: dec17, service: "CLI", creditsUsed: 1),
-        ]
-
-        let breakdown = OpenAIDashboardSnapshot.makeDailyBreakdown(from: events, maxDays: 30)
-        #expect(breakdown.count == 2)
-        #expect(breakdown.first?.services.first?.service == "CLI")
-        #expect(abs((breakdown.first?.services.first?.creditsUsed ?? 0) - 15) < 0.0001)
-    }
-
-    @Test
-    func `decodes snapshot without usage breakdown field`() throws {
-        let json = """
-        {
-          "signedInEmail": "user@example.com",
-          "codeReviewRemainingPercent": 42,
-          "creditEvents": [],
-          "dailyBreakdown": [],
-          "updatedAt": "2025-12-18T00:00:00Z"
-        }
-        """
-        let decoder = JSONDecoder()
-        decoder.dateDecodingStrategy = .iso8601
-        let snapshot = try decoder.decode(OpenAIDashboardSnapshot.self, from: Data(json.utf8))
-        #expect(snapshot.usageBreakdown.isEmpty)
-    }
-}

package/Tests/RunicTests/OpenAIWebAccountSwitchTests.swift

@@ -1,64 +0,0 @@
-import Foundation
-import RunicCore
-import Testing
-@testable import Runic
-
-@MainActor
-struct OpenAIWebAccountSwitchTests {
-    @Test
-    func `clears dashboard when codex email changes`() {
-        let settings = SettingsStore(
-            zaiTokenStore: NoopZaiTokenStore(),
-            minimaxTokenStore: NoopMiniMaxTokenStore(),
-            minimaxCookieHeaderStore: NoopMiniMaxCookieHeaderStore(),
-            minimaxGroupIDStore: NoopMiniMaxGroupIDStore(),
-            openRouterTokenStore: NoopOpenRouterTokenStore(),
-            groqTokenStore: NoopGroqTokenStore())
-        settings.refreshFrequency = .manual
-
-        let store = UsageStore(fetcher: UsageFetcher(), settings: settings)
-
-        store.handleOpenAIWebTargetEmailChangeIfNeeded(targetEmail: "a@example.com")
-        store.openAIDashboard = OpenAIDashboardSnapshot(
-            signedInEmail: "a@example.com",
-            codeReviewRemainingPercent: 100,
-            creditEvents: [],
-            dailyBreakdown: [],
-            usageBreakdown: [],
-            creditsPurchaseURL: nil,
-            updatedAt: Date())
-
-        store.handleOpenAIWebTargetEmailChangeIfNeeded(targetEmail: "b@example.com")
-        #expect(store.openAIDashboard == nil)
-        #expect(store.openAIDashboardRequiresLogin == true)
-        #expect(store.openAIDashboardCookieImportStatus?.contains("Codex account changed") == true)
-    }
-
-    @Test
-    func `keeps dashboard when codex email stays same`() {
-        let settings = SettingsStore(
-            zaiTokenStore: NoopZaiTokenStore(),
-            minimaxTokenStore: NoopMiniMaxTokenStore(),
-            minimaxCookieHeaderStore: NoopMiniMaxCookieHeaderStore(),
-            minimaxGroupIDStore: NoopMiniMaxGroupIDStore(),
-            openRouterTokenStore: NoopOpenRouterTokenStore(),
-            groqTokenStore: NoopGroqTokenStore())
-        settings.refreshFrequency = .manual
-
-        let store = UsageStore(fetcher: UsageFetcher(), settings: settings)
-
-        store.handleOpenAIWebTargetEmailChangeIfNeeded(targetEmail: "a@example.com")
-        let dash = OpenAIDashboardSnapshot(
-            signedInEmail: "a@example.com",
-            codeReviewRemainingPercent: 100,
-            creditEvents: [],
-            dailyBreakdown: [],
-            usageBreakdown: [],
-            creditsPurchaseURL: nil,
-            updatedAt: Date())
-        store.openAIDashboard = dash
-
-        store.handleOpenAIWebTargetEmailChangeIfNeeded(targetEmail: "a@example.com")
-        #expect(store.openAIDashboard == dash)
-    }
-}

package/Tests/RunicTests/OpenRouterTokenStoreTestSupport.swift

@@ -1,131 +0,0 @@
-@testable import Runic
-
-struct NoopOpenRouterTokenStore: OpenRouterTokenStoring {
-    func loadToken() throws -> String? {
-        nil
-    }
-
-    func storeToken(_ token: String?) throws {
-        _ = token
-    }
-}
-
-struct NoopGroqTokenStore: GroqTokenStoring {
-    func loadToken() throws -> String? {
-        nil
-    }
-
-    func storeToken(_ token: String?) throws {
-        _ = token
-    }
-}
-
-struct NoopDeepSeekTokenStore: DeepSeekTokenStoring {
-    func loadToken() throws -> String? {
-        nil
-    }
-
-    func storeToken(_ token: String?) throws {
-        _ = token
-    }
-}
-
-struct NoopFireworksTokenStore: FireworksTokenStoring {
-    func loadToken() throws -> String? {
-        nil
-    }
-
-    func storeToken(_ token: String?) throws {
-        _ = token
-    }
-}
-
-struct NoopMistralTokenStore: MistralTokenStoring {
-    func loadToken() throws -> String? {
-        nil
-    }
-
-    func storeToken(_ token: String?) throws {
-        _ = token
-    }
-}
-
-struct NoopPerplexityTokenStore: PerplexityTokenStoring {
-    func loadToken() throws -> String? {
-        nil
-    }
-
-    func storeToken(_ token: String?) throws {
-        _ = token
-    }
-}
-
-struct NoopKimiTokenStore: KimiTokenStoring {
-    func loadToken() throws -> String? {
-        nil
-    }
-
-    func storeToken(_ token: String?) throws {
-        _ = token
-    }
-}
-
-struct NoopAuggieTokenStore: AuggieTokenStoring {
-    func loadToken() throws -> String? {
-        nil
-    }
-
-    func storeToken(_ token: String?) throws {
-        _ = token
-    }
-}
-
-struct NoopTogetherTokenStore: TogetherTokenStoring {
-    func loadToken() throws -> String? {
-        nil
-    }
-
-    func storeToken(_ token: String?) throws {
-        _ = token
-    }
-}
-
-struct NoopCohereTokenStore: CohereTokenStoring {
-    func loadToken() throws -> String? {
-        nil
-    }
-
-    func storeToken(_ token: String?) throws {
-        _ = token
-    }
-}
-
-struct NoopXAITokenStore: XAITokenStoring {
-    func loadToken() throws -> String? {
-        nil
-    }
-
-    func storeToken(_ token: String?) throws {
-        _ = token
-    }
-}
-
-struct NoopCerebrasTokenStore: CerebrasTokenStoring {
-    func loadToken() throws -> String? {
-        nil
-    }
-
-    func storeToken(_ token: String?) throws {
-        _ = token
-    }
-}
-
-struct NoopSambaNovaTokenStore: SambaNovaTokenStoring {
-    func loadToken() throws -> String? {
-        nil
-    }
-
-    func storeToken(_ token: String?) throws {
-        _ = token
-    }
-}