@sriinnu/runic 1.0.0

package/Tests/RunicTests/AntigravityStatusProbeTests.swift

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

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

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

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

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

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

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

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

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

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