@sriinnu/runic 1.2.0 → 2.11.1

package/Tests/RunicTests/AntigravityStatusProbeTests.swift

@@ -1,50 +0,0 @@
-import RunicCore
-import XCTest
-
-final class AntigravityStatusProbeTests: XCTestCase {
-    func test_parsesUserStatusResponse() throws {
-        let json = """
-        {
-          "code": 0,
-          "userStatus": {
-            "email": "test@example.com",
-            "planStatus": {
-              "planInfo": {
-                "planName": "Pro"
-              }
-            },
-            "cascadeModelConfigData": {
-              "clientModelConfigs": [
-                {
-                  "label": "Claude 3.5 Sonnet",
-                  "modelOrAlias": { "model": "claude-3-5-sonnet" },
-                  "quotaInfo": { "remainingFraction": 0.5, "resetTime": "2025-12-24T10:00:00Z" }
-                },
-                {
-                  "label": "Gemini Pro Low",
-                  "modelOrAlias": { "model": "gemini-pro-low" },
-                  "quotaInfo": { "remainingFraction": 0.8, "resetTime": "2025-12-24T11:00:00Z" }
-                },
-                {
-                  "label": "Gemini Flash",
-                  "modelOrAlias": { "model": "gemini-flash" },
-                  "quotaInfo": { "remainingFraction": 0.2, "resetTime": "2025-12-24T12:00:00Z" }
-                }
-              ]
-            }
-          }
-        }
-        """
-
-        let data = Data(json.utf8)
-        let snapshot = try AntigravityStatusProbe.parseUserStatusResponse(data)
-        XCTAssertEqual(snapshot.accountEmail, "test@example.com")
-        XCTAssertEqual(snapshot.accountPlan, "Pro")
-        XCTAssertEqual(snapshot.modelQuotas.count, 3)
-
-        let usage = try snapshot.toUsageSnapshot()
-        XCTAssertEqual(usage.primary.remainingPercent.rounded(), 50)
-        XCTAssertEqual(usage.secondary?.remainingPercent.rounded(), 80)
-        XCTAssertEqual(usage.tertiary?.remainingPercent.rounded(), 20)
-    }
-}

package/Tests/RunicTests/AppDelegateTests.swift

@@ -1,43 +0,0 @@
-import AppKit
-import RunicCore
-import Testing
-@testable import Runic
-
-@MainActor
-@Suite
-struct AppDelegateTests {
-    @Test
-    func buildsStatusControllerAfterLaunch() {
-        let appDelegate = AppDelegate()
-        var factoryCalls = 0
-
-        // Install a test factory that records invocations without touching NSStatusBar.
-        StatusItemController.factory = { _, _, _, _, _ in
-            factoryCalls += 1
-            return DummyStatusController()
-        }
-        defer { StatusItemController.factory = StatusItemController.defaultFactory }
-
-        let settings = SettingsStore(zaiTokenStore: NoopZaiTokenStore(), minimaxTokenStore: NoopMiniMaxTokenStore(), minimaxCookieHeaderStore: NoopMiniMaxCookieHeaderStore(), minimaxGroupIDStore: NoopMiniMaxGroupIDStore(), openRouterTokenStore: NoopOpenRouterTokenStore(), groqTokenStore: NoopGroqTokenStore())
-        let fetcher = UsageFetcher()
-        let store = UsageStore(fetcher: fetcher, settings: settings)
-        let account = fetcher.loadAccountInfo()
-
-        // configure should not eagerly construct the status controller
-        appDelegate.configure(store: store, settings: settings, account: account, selection: PreferencesSelection())
-        #expect(factoryCalls == 0)
-
-        // construction happens once after launch
-        appDelegate.applicationDidFinishLaunching(Notification(name: NSApplication.didFinishLaunchingNotification))
-        #expect(factoryCalls == 1)
-
-        // idempotent on subsequent calls
-        appDelegate.applicationDidFinishLaunching(Notification(name: NSApplication.didFinishLaunchingNotification))
-        #expect(factoryCalls == 1)
-    }
-}
-
-@MainActor
-private final class DummyStatusController: StatusItemControlling {
-    func openMenuFromShortcut() {}
-}

package/Tests/RunicTests/BrowserCookieOrderLabelTests.swift

@@ -1,22 +0,0 @@
-import RunicCore
-import Silo
-import Testing
-
-@Suite
-struct BrowserCookieOrderStatusStringTests {
-    #if os(macOS)
-    @Test
-    func cursorNoSessionIncludesBrowserLoginHint() {
-        let order = ProviderDefaults.metadata[.cursor]?.browserCookieOrder ?? Browser.defaultImportOrder
-        let message = CursorStatusProbeError.noSessionCookie.errorDescription ?? ""
-        #expect(message.contains(order.loginHint))
-    }
-
-    @Test
-    func factoryNoSessionIncludesBrowserLoginHint() {
-        let order = ProviderDefaults.metadata[.factory]?.browserCookieOrder ?? Browser.defaultImportOrder
-        let message = FactoryStatusProbeError.noSessionCookie.errorDescription ?? ""
-        #expect(message.contains(order.loginHint))
-    }
-    #endif
-}

package/Tests/RunicTests/CLIArgumentParsingTests.swift

@@ -1,70 +0,0 @@
-import Helix
-import Testing
-
-@Suite
-struct CLIArgumentParsingTests {
-    @Test
-    func usageCommandParsesProviderAndJsonFlags() throws {
-        let signature = CommandSignature(
-            options: [
-                OptionDefinition(label: "provider", names: [.long("provider")], help: nil),
-                OptionDefinition(label: "format", names: [.long("format")], help: nil),
-            ],
-            flags: [
-                FlagDefinition(label: "json", names: [.long("json")], help: nil),
-                FlagDefinition(label: "pretty", names: [.long("pretty")], help: nil),
-                FlagDefinition(label: "noColor", names: [.long("no-color")], help: nil),
-            ])
-        let parser = CommandParser(signature: signature)
-        let parsed = try parser.parse(arguments: ["--provider", "codex", "--json", "--pretty", "--no-color"])
-
-        #expect(parsed.options["provider"] == ["codex"])
-        #expect(parsed.flags.contains("json"))
-        #expect(parsed.flags.contains("pretty"))
-        #expect(parsed.flags.contains("noColor"))
-    }
-
-    @Test
-    func costCommandParsesRefreshFlag() throws {
-        let signature = CommandSignature(
-            options: [
-                OptionDefinition(label: "provider", names: [.long("provider")], help: nil),
-            ],
-            flags: [
-                FlagDefinition(label: "refresh", names: [.long("refresh")], help: nil),
-            ])
-        let parser = CommandParser(signature: signature)
-        let parsed = try parser.parse(arguments: ["--provider", "claude", "--refresh"])
-
-        #expect(parsed.options["provider"] == ["claude"])
-        #expect(parsed.flags.contains("refresh"))
-    }
-
-    @Test
-    func insightsCommandParsesViewAndBudgetFlags() throws {
-        let signature = CommandSignature(
-            options: [
-                OptionDefinition(label: "view", names: [.long("view")], help: nil),
-                OptionDefinition(label: "project", names: [.long("project")], help: nil),
-                OptionDefinition(label: "timezone", names: [.long("timezone")], help: nil),
-            ],
-            flags: [
-                FlagDefinition(label: "budget", names: [.long("budget")], help: nil),
-                FlagDefinition(label: "withCommits", names: [.long("with-commits")], help: nil),
-            ])
-        let parser = CommandParser(signature: signature)
-        let parsed = try parser.parse(arguments: [
-            "--view", "projects",
-            "--project", "runic",
-            "--timezone", "America/Los_Angeles",
-            "--budget",
-            "--with-commits",
-        ])
-
-        #expect(parsed.options["view"] == ["projects"])
-        #expect(parsed.options["project"] == ["runic"])
-        #expect(parsed.options["timezone"] == ["America/Los_Angeles"])
-        #expect(parsed.flags.contains("budget"))
-        #expect(parsed.flags.contains("withCommits"))
-    }
-}

package/Tests/RunicTests/CLICostTests.swift

@@ -1,65 +0,0 @@
-import Foundation
-import RunicCore
-import Testing
-
-@Suite
-struct CLICostTests {
-    @Test
-    func costSnapshotStoresSessionAndMonthFields() {
-        let snapshot = CostUsageTokenSnapshot(
-            sessionTokens: 1_200,
-            sessionCostUSD: 1.25,
-            last30DaysTokens: 9_000,
-            last30DaysCostUSD: 9.99,
-            daily: [],
-            updatedAt: Date(timeIntervalSince1970: 1_700_000_000))
-
-        #expect(snapshot.sessionTokens == 1_200)
-        #expect(snapshot.sessionCostUSD == 1.25)
-        #expect(snapshot.last30DaysTokens == 9_000)
-        #expect(snapshot.last30DaysCostUSD == 9.99)
-    }
-
-    @Test
-    func dailyReportDecodesLegacyCacheTokenKeys() throws {
-        let json = """
-        {
-          "daily": [
-            {
-              "date": "2025-12-20",
-              "inputTokens": 10,
-              "outputTokens": 5,
-              "cacheReadInputTokens": 2,
-              "cacheCreationInputTokens": 3,
-              "totalTokens": 20,
-              "totalCost": 0.01,
-              "models": {
-                "claude-sonnet-4-20250514": 20
-              }
-            }
-          ],
-          "totals": {
-            "totalInputTokens": 10,
-            "totalOutputTokens": 5,
-            "totalCacheReadTokens": 2,
-            "totalCacheCreationTokens": 3,
-            "totalTokens": 20,
-            "totalCost": 0.01
-          }
-        }
-        """
-
-        let data = try #require(json.data(using: .utf8))
-        let report = try JSONDecoder().decode(CostUsageDailyReport.self, from: data)
-        let entry = try #require(report.data.first)
-        let summary = try #require(report.summary)
-
-        #expect(entry.cacheReadTokens == 2)
-        #expect(entry.cacheCreationTokens == 3)
-        #expect(entry.costUSD == 0.01)
-        #expect(entry.modelsUsed == ["claude-sonnet-4-20250514"])
-        #expect(summary.cacheReadTokens == 2)
-        #expect(summary.cacheCreationTokens == 3)
-        #expect(summary.totalCostUSD == 0.01)
-    }
-}

package/Tests/RunicTests/CLIProviderSelectionTests.swift

@@ -1,22 +0,0 @@
-import RunicCore
-import Testing
-
-@Suite
-struct CLIProviderSelectionTests {
-    @Test
-    func providerRegistryIncludesCoreProviders() {
-        let providers = Set(ProviderDescriptorRegistry.all.map(\.id))
-
-        #expect(providers.contains(.codex))
-        #expect(providers.contains(.claude))
-        #expect(providers.contains(.gemini))
-        #expect(providers.contains(.cursor))
-        #expect(providers.contains(.factory))
-    }
-
-    @Test
-    func providerEnumResolvesInsightsSupportedValues() {
-        #expect(UsageProvider(rawValue: "codex") == .codex)
-        #expect(UsageProvider(rawValue: "claude") == .claude)
-    }
-}

package/Tests/RunicTests/CLISnapshotTests.swift

@@ -1,72 +0,0 @@
-import Foundation
-import RunicCore
-import Testing
-@testable import RunicCLI
-
-@Suite
-struct CLISnapshotTests {
-    @Test
-    func rendersCodexTextSnapshot() {
-        let identity = ProviderIdentitySnapshot(
-            providerID: .codex,
-            accountEmail: "user@example.com",
-            accountOrganization: nil,
-            loginMethod: "pro")
-        let snapshot = UsageSnapshot(
-            primary: .init(usedPercent: 12, windowMinutes: 300, resetsAt: nil, resetDescription: "today at 3:00 PM"),
-            secondary: .init(usedPercent: 25, windowMinutes: 10080, resetsAt: nil, resetDescription: "Fri at 9:00 AM"),
-            tertiary: nil,
-            updatedAt: Date(timeIntervalSince1970: 0),
-            identity: identity)
-
-        let output = CLIRenderer.renderText(
-            provider: .codex,
-            snapshot: snapshot,
-            credits: CreditsSnapshot(remaining: 42, events: [], updatedAt: Date()),
-            context: RenderContext(header: "Codex 1.2.3 (codex-cli)", useColor: false))
-
-        #expect(output.contains("Codex 1.2.3 (codex-cli)"))
-        #expect(output.contains("Session"))
-        #expect(output.contains("Weekly"))
-        #expect(output.contains("Credits: 42"))
-        #expect(output.contains("Account: user@example.com"))
-        #expect(output.contains("Plan: Pro"))
-    }
-
-    @Test
-    func rendersClaudeSnapshotWithoutWeeklyWhenMissing() {
-        let snapshot = UsageSnapshot(
-            primary: .init(usedPercent: 2, windowMinutes: nil, resetsAt: nil, resetDescription: "3pm (Europe/Vienna)"),
-            secondary: nil,
-            tertiary: nil,
-            updatedAt: Date(timeIntervalSince1970: 0))
-
-        let output = CLIRenderer.renderText(
-            provider: .claude,
-            snapshot: snapshot,
-            credits: nil,
-            context: RenderContext(header: "Claude Code 2.0.69 (claude)", useColor: false))
-
-        #expect(output.contains("Session"))
-        #expect(!output.contains("Weekly:"))
-    }
-
-    @Test
-    func appliesAnsiColorsWhenEnabled() {
-        let snapshot = UsageSnapshot(
-            primary: .init(usedPercent: 95, windowMinutes: 300, resetsAt: nil, resetDescription: nil),
-            secondary: .init(usedPercent: 80, windowMinutes: 10080, resetsAt: nil, resetDescription: nil),
-            tertiary: nil,
-            updatedAt: Date(timeIntervalSince1970: 0))
-
-        let output = CLIRenderer.renderText(
-            provider: .codex,
-            snapshot: snapshot,
-            credits: nil,
-            context: RenderContext(header: "Codex 0.0.0 (codex-cli)", useColor: true))
-
-        #expect(output.contains("\u{001B}[1;36mCodex 0.0.0 (codex-cli)\u{001B}[0m"))
-        #expect(output.contains("\u{001B}[31m"))
-        #expect(output.contains("\u{001B}[33m"))
-    }
-}

package/Tests/RunicTests/CLIWebFallbackTests.swift

@@ -1,58 +0,0 @@
-import Testing
-@testable import RunicCLI
-@testable import RunicCore
-
-@Suite
-struct CLIWebFallbackTests {
-    private func makeContext(sourceMode: ProviderSourceMode = .auto) -> ProviderFetchContext {
-        ProviderFetchContext(
-            runtime: .cli,
-            sourceMode: sourceMode,
-            includeCredits: true,
-            webTimeout: 60,
-            webDebugDumpHTML: false,
-            verbose: false,
-            env: [:],
-            settings: nil,
-            fetcher: UsageFetcher(),
-            claudeFetcher: ClaudeUsageFetcher())
-    }
-
-    @Test
-    func codexFallsBackWhenCookiesMissing() {
-        let context = self.makeContext()
-        let strategy = CodexWebDashboardStrategy()
-        #expect(strategy.shouldFallback(
-            on: OpenAIDashboardBrowserCookieImporter.ImportError.noCookiesFound,
-            context: context))
-        #expect(strategy.shouldFallback(
-            on: OpenAIDashboardBrowserCookieImporter.ImportError.noMatchingAccount(found: []),
-            context: context))
-        #expect(strategy.shouldFallback(
-            on: OpenAIDashboardBrowserCookieImporter.ImportError.browserAccessDenied(details: "no access"),
-            context: context))
-        #expect(strategy.shouldFallback(
-            on: OpenAIDashboardBrowserCookieImporter.ImportError.dashboardStillRequiresLogin,
-            context: context))
-        #expect(strategy.shouldFallback(
-            on: OpenAIDashboardFetcher.FetchError.loginRequired,
-            context: context))
-    }
-
-    @Test
-    func codexDoesNotFallbackForDashboardDataErrors() {
-        let context = self.makeContext()
-        let strategy = CodexWebDashboardStrategy()
-        #expect(!strategy.shouldFallback(
-            on: OpenAIDashboardFetcher.FetchError.noDashboardData(body: "missing"),
-            context: context))
-    }
-
-    @Test
-    func claudeFallsBackWhenNoSessionKey() {
-        let context = self.makeContext()
-        let strategy = ClaudeWebFetchStrategy()
-        #expect(strategy.shouldFallback(on: ClaudeWebAPIFetcher.FetchError.noSessionKeyFound, context: context))
-        #expect(!strategy.shouldFallback(on: ClaudeWebAPIFetcher.FetchError.unauthorized, context: context))
-    }
-}

package/Tests/RunicTests/ClaudeOAuthTests.swift

@@ -1,164 +0,0 @@
-import RunicCore
-import Foundation
-import Testing
-
-@Suite
-struct ClaudeOAuthTests {
-    @Test
-    func parsesOAuthCredentials() throws {
-        let json = """
-        {
-          "claudeAiOauth": {
-            "accessToken": "test-token",
-            "refreshToken": "test-refresh",
-            "expiresAt": 4102444800000,
-            "scopes": ["usage:read"],
-            "rateLimitTier": "default_claude_max_20x"
-          }
-        }
-        """
-        let creds = try ClaudeOAuthCredentials.parse(data: Data(json.utf8))
-        #expect(creds.accessToken == "test-token")
-        #expect(creds.refreshToken == "test-refresh")
-        #expect(creds.scopes == ["usage:read"])
-        #expect(creds.rateLimitTier == "default_claude_max_20x")
-        #expect(creds.isExpired == false)
-    }
-
-    @Test
-    func missingAccessTokenThrows() {
-        let json = """
-        {
-          "claudeAiOauth": {
-            "accessToken": "",
-            "refreshToken": "test-refresh",
-            "expiresAt": 1735689600000
-          }
-        }
-        """
-        #expect(throws: ClaudeOAuthCredentialsError.self) {
-            _ = try ClaudeOAuthCredentials.parse(data: Data(json.utf8))
-        }
-    }
-
-    @Test
-    func missingOAuthBlockThrows() {
-        let json = """
-        { "other": { "accessToken": "nope" } }
-        """
-        #expect(throws: ClaudeOAuthCredentialsError.self) {
-            _ = try ClaudeOAuthCredentials.parse(data: Data(json.utf8))
-        }
-    }
-
-    @Test
-    func treatsMissingExpiryAsExpired() {
-        let creds = ClaudeOAuthCredentials(
-            accessToken: "token",
-            refreshToken: nil,
-            expiresAt: nil,
-            scopes: [],
-            rateLimitTier: nil)
-        #expect(creds.isExpired == true)
-    }
-
-    @Test
-    func mapsOAuthUsageToSnapshot() throws {
-        let json = """
-        {
-          "five_hour": { "utilization": 12.5, "resets_at": "2025-12-25T12:00:00.000Z" },
-          "seven_day": { "utilization": 30, "resets_at": "2025-12-31T00:00:00.000Z" },
-          "seven_day_sonnet": { "utilization": 5 }
-        }
-        """
-        let snap = try ClaudeUsageFetcher._mapOAuthUsageForTesting(
-            Data(json.utf8),
-            rateLimitTier: "claude_pro")
-        #expect(snap.primary.usedPercent == 12.5)
-        #expect(snap.primary.windowMinutes == 300)
-        #expect(snap.secondary?.usedPercent == 30)
-        #expect(snap.opus?.usedPercent == 5)
-        #expect(snap.primary.resetsAt != nil)
-        #expect(snap.loginMethod == "Claude Pro")
-    }
-
-    @Test
-    func mapsOAuthExtraUsage() throws {
-        let json = """
-        {
-          "five_hour": { "utilization": 1, "resets_at": "2025-12-25T12:00:00.000Z" },
-          "extra_usage": {
-            "is_enabled": true,
-            "monthly_limit": 20.5,
-            "used_credits": 3.25
-          }
-        }
-        """
-        let snap = try ClaudeUsageFetcher._mapOAuthUsageForTesting(Data(json.utf8))
-        #expect(snap.providerCost?.currencyCode == "USD")
-        #expect(snap.providerCost?.limit == 20.5)
-        #expect(snap.providerCost?.used == 3.25)
-    }
-
-    @Test
-    func prefersOpusWhenSonnetMissing() throws {
-        let json = """
-        {
-          "five_hour": { "utilization": 10, "resets_at": "2025-12-25T12:00:00.000Z" },
-          "seven_day_opus": { "utilization": 42 }
-        }
-        """
-        let snap = try ClaudeUsageFetcher._mapOAuthUsageForTesting(Data(json.utf8))
-        #expect(snap.opus?.usedPercent == 42)
-    }
-
-    @Test
-    func skipsExtraUsageWhenDisabled() throws {
-        let json = """
-        {
-          "five_hour": { "utilization": 1, "resets_at": "2025-12-25T12:00:00.000Z" },
-          "extra_usage": {
-            "is_enabled": false,
-            "monthly_limit": 100,
-            "used_credits": 10
-          }
-        }
-        """
-        let snap = try ClaudeUsageFetcher._mapOAuthUsageForTesting(Data(json.utf8))
-        #expect(snap.providerCost == nil)
-    }
-
-    // MARK: - Scope-based strategy resolution
-
-    @Test
-    func oauthRequiresUserProfileScope() {
-        // With user:profile scope, OAuth should be selected.
-        let withProfile = ClaudeProviderDescriptor.resolveUsageStrategy(
-            debugMenuEnabled: false,
-            selectedDataSource: .oauth,
-            webExtrasEnabled: false,
-            hasWebSession: true,
-            hasOAuthCredentials: true)
-        #expect(withProfile.dataSource == .oauth)
-
-        // Without user:profile scope (hasOAuthCredentials=false), should fall back to web.
-        let withoutProfile = ClaudeProviderDescriptor.resolveUsageStrategy(
-            debugMenuEnabled: false,
-            selectedDataSource: .oauth,
-            webExtrasEnabled: false,
-            hasWebSession: true,
-            hasOAuthCredentials: false)
-        #expect(withoutProfile.dataSource == .web)
-    }
-
-    @Test
-    func fallsBackToCLIWhenNoWebOrOAuth() {
-        let strategy = ClaudeProviderDescriptor.resolveUsageStrategy(
-            debugMenuEnabled: false,
-            selectedDataSource: .oauth,
-            webExtrasEnabled: false,
-            hasWebSession: false,
-            hasOAuthCredentials: false)
-        #expect(strategy.dataSource == .cli)
-    }
-}

package/Tests/RunicTests/ClaudeResilienceTests.swift

@@ -1,30 +0,0 @@
-import Testing
-@testable import Runic
-
-@Suite
-struct ClaudeResilienceTests {
-    @Test
-    func suppressesSingleFlakeWhenPriorDataExists() {
-        var gate = ConsecutiveFailureGate()
-        let firstFailure = gate.shouldSurfaceError(onFailureWithPriorData: true)
-        let secondFailure = gate.shouldSurfaceError(onFailureWithPriorData: true)
-        #expect(firstFailure == false)
-        #expect(secondFailure == true)
-    }
-
-    @Test
-    func surfacesFailureWithoutPriorData() {
-        var gate = ConsecutiveFailureGate()
-        let shouldSurface = gate.shouldSurfaceError(onFailureWithPriorData: false)
-        #expect(shouldSurface)
-    }
-
-    @Test
-    func resetsAfterSuccess() {
-        var gate = ConsecutiveFailureGate()
-        _ = gate.shouldSurfaceError(onFailureWithPriorData: true)
-        gate.recordSuccess()
-        let shouldSurface = gate.shouldSurfaceError(onFailureWithPriorData: true)
-        #expect(shouldSurface == false)
-    }
-}