@sriinnu/runic 2.0.0 → 2.11.1

package/Tests/RunicTests/UsageLedgerInsightsAdvisorTests.swift

@@ -1,81 +0,0 @@
-import Foundation
-import Testing
-@testable import RunicCore
-
-struct UsageLedgerInsightsAdvisorTests {
-    @Test
-    func `reliability score drops when errors exist`() {
-        let now = Date()
-        let daily = UsageLedgerDailySummary(
-            provider: .codex,
-            projectID: nil,
-            dayStart: now,
-            dayKey: "2026-02-21",
-            totals: UsageLedgerTotals(
-                inputTokens: 1000,
-                outputTokens: 500,
-                cacheCreationTokens: 100,
-                cacheReadTokens: 200,
-                costUSD: 2.5),
-            modelsUsed: ["gpt-5"])
-
-        let scoreWithoutErrors = UsageLedgerInsightsAdvisor.reliabilityScore(
-            provider: .codex,
-            daily: daily,
-            activeBlock: nil,
-            modelBreakdown: [],
-            projectBreakdown: [],
-            providerError: nil,
-            ledgerError: nil)
-        let scoreWithErrors = UsageLedgerInsightsAdvisor.reliabilityScore(
-            provider: .codex,
-            daily: daily,
-            activeBlock: nil,
-            modelBreakdown: [],
-            projectBreakdown: [],
-            providerError: "fetch failed",
-            ledgerError: "parse failed")
-
-        #expect(scoreWithoutErrors != nil)
-        #expect(scoreWithErrors != nil)
-        #expect((scoreWithErrors?.score ?? 0) < (scoreWithoutErrors?.score ?? 100))
-    }
-
-    @Test
-    func `routing recommendation finds savings between models`() {
-        let expensive = UsageLedgerModelSummary(
-            provider: .codex,
-            projectID: "proj-a",
-            projectName: "Project A",
-            model: "gpt-5",
-            entryCount: 20,
-            totals: UsageLedgerTotals(
-                inputTokens: 30000,
-                outputTokens: 20000,
-                cacheCreationTokens: 0,
-                cacheReadTokens: 0,
-                costUSD: 12.0))
-
-        let cheaper = UsageLedgerModelSummary(
-            provider: .codex,
-            projectID: "proj-a",
-            projectName: "Project A",
-            model: "gpt-5-mini",
-            entryCount: 30,
-            totals: UsageLedgerTotals(
-                inputTokens: 40000,
-                outputTokens: 20000,
-                cacheCreationTokens: 0,
-                cacheReadTokens: 0,
-                costUSD: 3.0))
-
-        let recommendation = UsageLedgerInsightsAdvisor.routingRecommendation(
-            modelBreakdown: [expensive, cheaper],
-            shiftPercent: 0.20)
-
-        #expect(recommendation != nil)
-        #expect((recommendation?.estimatedSavingsUSD ?? 0) > 0)
-        #expect(recommendation?.fromModel == "gpt-5")
-        #expect(recommendation?.toModel == "gpt-5-mini")
-    }
-}

package/Tests/RunicTests/UsageLedgerProjectNameTests.swift

@@ -1,168 +0,0 @@
-import Foundation
-import Testing
-@testable import RunicCore
-
-struct UsageLedgerProjectNameTests {
-    @Test
-    func `project summaries prefer non empty project name`() {
-        let now = Date()
-        let entries = [
-            UsageLedgerEntry(
-                provider: .codex,
-                timestamp: now,
-                sessionID: "s1",
-                projectID: "proj-123",
-                projectName: "   ",
-                model: "gpt-5",
-                inputTokens: 10,
-                outputTokens: 5,
-                cacheCreationTokens: 0,
-                cacheReadTokens: 0,
-                costUSD: 0.01,
-                requestID: "r1",
-                messageID: nil,
-                version: nil,
-                source: .codexLog),
-            UsageLedgerEntry(
-                provider: .codex,
-                timestamp: now.addingTimeInterval(1),
-                sessionID: "s1",
-                projectID: "proj-123",
-                projectName: "Core Platform",
-                model: "gpt-5",
-                inputTokens: 20,
-                outputTokens: 10,
-                cacheCreationTokens: 0,
-                cacheReadTokens: 0,
-                costUSD: 0.03,
-                requestID: "r2",
-                messageID: nil,
-                version: nil,
-                source: .codexLog),
-        ]
-
-        let projectSummary = UsageLedgerAggregator.projectSummaries(entries: entries).first
-        #expect(projectSummary?.projectID == "proj-123")
-        #expect(projectSummary?.projectName == "Core Platform")
-
-        let modelSummary = UsageLedgerAggregator.modelSummaries(entries: entries, groupByProject: true).first
-        #expect(modelSummary?.projectID == "proj-123")
-        #expect(modelSummary?.projectName == "Core Platform")
-    }
-
-    @Test
-    func `project summaries group by inferred name when project ID is missing`() {
-        let now = Date()
-        let entries = [
-            UsageLedgerEntry(
-                provider: .codex,
-                timestamp: now,
-                sessionID: "s1",
-                projectID: nil,
-                projectName: "Alpha Workspace",
-                model: "gpt-5",
-                inputTokens: 50,
-                outputTokens: 10,
-                cacheCreationTokens: 0,
-                cacheReadTokens: 0,
-                costUSD: 0.10,
-                requestID: "ra",
-                messageID: nil,
-                version: nil,
-                source: .codexLog),
-            UsageLedgerEntry(
-                provider: .codex,
-                timestamp: now.addingTimeInterval(5),
-                sessionID: "s2",
-                projectID: nil,
-                projectName: "Beta Workspace",
-                model: "gpt-5",
-                inputTokens: 40,
-                outputTokens: 15,
-                cacheCreationTokens: 0,
-                cacheReadTokens: 0,
-                costUSD: 0.12,
-                requestID: "rb",
-                messageID: nil,
-                version: nil,
-                source: .codexLog),
-        ]
-
-        let summaries = UsageLedgerAggregator.projectSummaries(entries: entries)
-        #expect(summaries.count == 2)
-        let names = Set(summaries.map(\.projectName).compactMap(\.self))
-        #expect(names.contains("Alpha Workspace"))
-        #expect(names.contains("Beta Workspace"))
-    }
-
-    @Test
-    func `project summaries infer project name from path like identifier`() {
-        let now = Date()
-        let entries = [
-            UsageLedgerEntry(
-                provider: .codex,
-                timestamp: now,
-                sessionID: "s1",
-                projectID: "/Users/me/workspace/Runic-App",
-                projectName: nil,
-                model: "gpt-5",
-                inputTokens: 100,
-                outputTokens: 30,
-                cacheCreationTokens: 0,
-                cacheReadTokens: 0,
-                costUSD: 0.30,
-                requestID: "r-path",
-                messageID: nil,
-                version: nil,
-                source: .codexLog),
-        ]
-
-        let summary = UsageLedgerAggregator.projectSummaries(entries: entries).first
-        #expect(summary != nil)
-        #expect(summary?.projectKey != nil)
-        #expect(summary?.projectNameSource == .inferredFromPath)
-        #expect(summary?.displayProjectName == "Runic-App")
-    }
-
-    @Test
-    func `project display name falls back to readable identifier`() {
-        let summary = UsageLedgerProjectSummary(
-            provider: .codex,
-            projectID: "runic-core",
-            projectName: nil,
-            projectNameConfidence: .low,
-            projectNameSource: .projectID,
-            projectNameProvenance: "entry.projectID",
-            entryCount: 1,
-            totals: UsageLedgerTotals(
-                inputTokens: 1,
-                outputTokens: 1,
-                cacheCreationTokens: 0,
-                cacheReadTokens: 0,
-                costUSD: nil),
-            modelsUsed: [])
-
-        #expect(summary.displayProjectName == "runic-core")
-    }
-
-    @Test
-    func `project display name keeps opaque identifiers hidden`() {
-        let summary = UsageLedgerProjectSummary(
-            provider: .codex,
-            projectID: "8f189f6bb4e9fa93a9a4bf5cf97a0b4d",
-            projectName: nil,
-            projectNameConfidence: .low,
-            projectNameSource: .projectID,
-            projectNameProvenance: "entry.projectID",
-            entryCount: 1,
-            totals: UsageLedgerTotals(
-                inputTokens: 1,
-                outputTokens: 1,
-                cacheCreationTokens: 0,
-                cacheReadTokens: 0,
-                costUSD: nil),
-            modelsUsed: [])
-
-        #expect(summary.displayProjectName == "Unknown project")
-    }
-}

package/Tests/RunicTests/UsagePaceTests.swift

@@ -1,76 +0,0 @@
-import Foundation
-import RunicCore
-import Testing
-
-struct UsagePaceTests {
-    @Test
-    func `weekly pace computes delta and eta`() {
-        let now = Date(timeIntervalSince1970: 0)
-        let window = RateWindow(
-            usedPercent: 50,
-            windowMinutes: 10080,
-            resetsAt: now.addingTimeInterval(4 * 24 * 3600),
-            resetDescription: nil)
-
-        let pace = UsagePace.weekly(window: window, now: now)
-
-        #expect(pace != nil)
-        guard let pace else { return }
-        #expect(abs(pace.expectedUsedPercent - 42.857) < 0.01)
-        #expect(abs(pace.deltaPercent - 7.143) < 0.01)
-        #expect(pace.stage == .ahead)
-        #expect(pace.willLastToReset == false)
-        #expect(pace.etaSeconds != nil)
-        #expect(abs((pace.etaSeconds ?? 0) - (3 * 24 * 3600)) < 1)
-    }
-
-    @Test
-    func `weekly pace marks lasts to reset when usage is low`() {
-        let now = Date(timeIntervalSince1970: 0)
-        let window = RateWindow(
-            usedPercent: 5,
-            windowMinutes: 10080,
-            resetsAt: now.addingTimeInterval(4 * 24 * 3600),
-            resetDescription: nil)
-
-        let pace = UsagePace.weekly(window: window, now: now)
-
-        #expect(pace != nil)
-        guard let pace else { return }
-        #expect(pace.willLastToReset == true)
-        #expect(pace.etaSeconds == nil)
-        #expect(pace.stage == .farBehind)
-    }
-
-    @Test
-    func `weekly pace hides when reset missing or outside window`() {
-        let now = Date(timeIntervalSince1970: 0)
-        let missing = RateWindow(
-            usedPercent: 10,
-            windowMinutes: 10080,
-            resetsAt: nil,
-            resetDescription: nil)
-        let tooFar = RateWindow(
-            usedPercent: 10,
-            windowMinutes: 10080,
-            resetsAt: now.addingTimeInterval(9 * 24 * 3600),
-            resetDescription: nil)
-
-        #expect(UsagePace.weekly(window: missing, now: now) == nil)
-        #expect(UsagePace.weekly(window: tooFar, now: now) == nil)
-    }
-
-    @Test
-    func `weekly pace hides when usage exists but no elapsed`() {
-        let now = Date(timeIntervalSince1970: 0)
-        let window = RateWindow(
-            usedPercent: 12,
-            windowMinutes: 10080,
-            resetsAt: now.addingTimeInterval(7 * 24 * 3600),
-            resetDescription: nil)
-
-        let pace = UsagePace.weekly(window: window, now: now)
-
-        #expect(pace == nil)
-    }
-}

package/Tests/RunicTests/UsagePaceTextTests.swift

@@ -1,108 +0,0 @@
-import Foundation
-import RunicCore
-import Testing
-@testable import Runic
-
-struct UsagePaceTextTests {
-    @Test
-    func `weekly pace text includes eta when running out before reset`() {
-        let now = Date(timeIntervalSince1970: 0)
-        let window = RateWindow(
-            usedPercent: 50,
-            windowMinutes: 10080,
-            resetsAt: now.addingTimeInterval(4 * 24 * 3600),
-            resetDescription: nil)
-
-        let text = UsagePaceText.weekly(provider: .codex, window: window, now: now)
-
-        #expect(text == "Pace: Ahead (+7%) · Runs out in 3d")
-    }
-
-    @Test
-    func `weekly pace text shows reset safe when pace is slow`() {
-        let now = Date(timeIntervalSince1970: 0)
-        let window = RateWindow(
-            usedPercent: 10,
-            windowMinutes: 10080,
-            resetsAt: now.addingTimeInterval(4 * 24 * 3600),
-            resetDescription: nil)
-
-        let text = UsagePaceText.weekly(provider: .codex, window: window, now: now)
-
-        #expect(text == "Pace: Behind (-33%) · Lasts to reset")
-    }
-
-    @Test
-    func `weekly pace text hides when reset is missing`() {
-        let now = Date(timeIntervalSince1970: 0)
-        let window = RateWindow(
-            usedPercent: 10,
-            windowMinutes: 10080,
-            resetsAt: nil,
-            resetDescription: nil)
-
-        let text = UsagePaceText.weekly(provider: .codex, window: window, now: now)
-
-        #expect(text == nil)
-    }
-
-    @Test
-    func `weekly pace text hides when reset is in past or too far`() {
-        let now = Date(timeIntervalSince1970: 0)
-        let pastWindow = RateWindow(
-            usedPercent: 10,
-            windowMinutes: 10080,
-            resetsAt: now.addingTimeInterval(-60),
-            resetDescription: nil)
-        let farFutureWindow = RateWindow(
-            usedPercent: 10,
-            windowMinutes: 10080,
-            resetsAt: now.addingTimeInterval(9 * 24 * 3600),
-            resetDescription: nil)
-
-        #expect(UsagePaceText.weekly(provider: .codex, window: pastWindow, now: now) == nil)
-        #expect(UsagePaceText.weekly(provider: .codex, window: farFutureWindow, now: now) == nil)
-    }
-
-    @Test
-    func `weekly pace text hides when no elapsed but usage exists`() {
-        let now = Date(timeIntervalSince1970: 0)
-        let window = RateWindow(
-            usedPercent: 5,
-            windowMinutes: 10080,
-            resetsAt: now.addingTimeInterval(7 * 24 * 3600),
-            resetDescription: nil)
-
-        let text = UsagePaceText.weekly(provider: .codex, window: window, now: now)
-
-        #expect(text == nil)
-    }
-
-    @Test
-    func `weekly pace text hides when too early in window`() {
-        let now = Date(timeIntervalSince1970: 0)
-        let window = RateWindow(
-            usedPercent: 40,
-            windowMinutes: 10080,
-            resetsAt: now.addingTimeInterval((7 * 24 * 3600) - (60 * 60)),
-            resetDescription: nil)
-
-        let text = UsagePaceText.weekly(provider: .codex, window: window, now: now)
-
-        #expect(text == nil)
-    }
-
-    @Test
-    func `weekly pace text hides when usage is depleted`() {
-        let now = Date(timeIntervalSince1970: 0)
-        let window = RateWindow(
-            usedPercent: 100,
-            windowMinutes: 10080,
-            resetsAt: now.addingTimeInterval(2 * 24 * 3600),
-            resetDescription: nil)
-
-        let text = UsagePaceText.weekly(provider: .codex, window: window, now: now)
-
-        #expect(text == nil)
-    }
-}

package/Tests/RunicTests/UsagePolicyEngineTests.swift

@@ -1,89 +0,0 @@
-import Testing
-@testable import RunicCore
-
-struct UsagePolicyEngineTests {
-    @Test
-    func `returns none when no rules match`() {
-        let context = UsagePolicyContext(
-            provider: .codex,
-            observedSpendUSD: 45,
-            projectedSpendUSD: 70,
-            budgetLimitUSD: 100,
-            anomalySeverity: .elevated)
-        let rules = [
-            UsagePolicyRule(
-                id: "hard-stop-over-budget",
-                name: "Hard stop after budget breach",
-                condition: .actualBudgetOverrun,
-                action: .hardStop),
-            UsagePolicyRule(
-                id: "critical-anomaly-soft-limit",
-                name: "Soft limit only on critical anomaly",
-                condition: .anomalySeverityAtLeast(.critical),
-                action: .softLimit),
-        ]
-
-        let decision = UsagePolicyEngine.evaluate(context: context, rules: rules)
-        #expect(decision.action == .none)
-        #expect(decision.matches.isEmpty)
-        #expect(decision.shouldThrottle == false)
-        #expect(decision.shouldBlock == false)
-    }
-
-    @Test
-    func `selects strongest action across matched rules`() {
-        let context = UsagePolicyContext(
-            provider: .codex,
-            observedSpendUSD: 120,
-            projectedSpendUSD: 170,
-            budgetLimitUSD: 100,
-            anomalySeverity: .critical)
-        let rules = [
-            UsagePolicyRule(
-                id: "warn-projected-20",
-                name: "Warn at projected +20%",
-                condition: .projectedBudgetOverrun(minimumPercent: 0.20),
-                action: .warn),
-            UsagePolicyRule(
-                id: "soft-anomaly-high",
-                name: "Soft limit on high anomaly",
-                condition: .anomalySeverityAtLeast(.high),
-                action: .softLimit),
-            UsagePolicyRule(
-                id: "stop-actual-overrun",
-                name: "Hard stop once actually over budget",
-                condition: .actualBudgetOverrun,
-                action: .hardStop),
-        ]
-
-        let decision = UsagePolicyEngine.evaluate(context: context, rules: rules)
-        #expect(decision.action == .hardStop)
-        #expect(decision.shouldThrottle == true)
-        #expect(decision.shouldBlock == true)
-        #expect(decision.matches.count == 3)
-        #expect(decision.matches.contains { $0.ruleID == "warn-projected-20" })
-        #expect(decision.matches.contains { $0.ruleID == "soft-anomaly-high" })
-        #expect(decision.matches.contains { $0.ruleID == "stop-actual-overrun" })
-    }
-
-    @Test
-    func `projected overrun condition respects threshold`() {
-        let context = UsagePolicyContext(
-            provider: .codex,
-            observedSpendUSD: 80,
-            projectedSpendUSD: 112,
-            budgetLimitUSD: 100,
-            anomalySeverity: nil)
-        let rules = [
-            UsagePolicyRule(
-                id: "warn-projected-20",
-                name: "Warn at projected +20%",
-                condition: .projectedBudgetOverrun(minimumPercent: 0.20),
-                action: .warn),
-        ]
-
-        let decision = UsagePolicyEngine.evaluate(context: context, rules: rules)
-        #expect(decision.action == .none)
-        #expect(decision.matches.isEmpty)
-    }
-}

package/Tests/RunicTests/WidgetSnapshotTests.swift

@@ -1,43 +0,0 @@
-import Foundation
-import Testing
-@testable import RunicCore
-
-struct WidgetSnapshotTests {
-    @Test
-    func `widget snapshot round trip`() throws {
-        let entry = WidgetSnapshot.ProviderEntry(
-            provider: .codex,
-            updatedAt: Date(),
-            primary: RateWindow(usedPercent: 10, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
-            secondary: RateWindow(usedPercent: 20, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
-            tertiary: nil,
-            creditsRemaining: 123.4,
-            codeReviewRemainingPercent: 80,
-            tokenUsage: WidgetSnapshot.TokenUsageSummary(
-                sessionCostUSD: 12.3,
-                sessionTokens: 1200,
-                last30DaysCostUSD: 456.7,
-                last30DaysTokens: 9800),
-            dailyUsage: [
-                WidgetSnapshot.DailyUsagePoint(dayKey: "2025-12-20", totalTokens: 1200, costUSD: 12.3),
-            ])
-
-        let snapshot = WidgetSnapshot(
-            entries: [entry],
-            enabledProviders: [.codex, .claude],
-            generatedAt: Date())
-
-        let encoder = JSONEncoder()
-        encoder.dateEncodingStrategy = .iso8601
-        let data = try encoder.encode(snapshot)
-
-        let decoder = JSONDecoder()
-        decoder.dateDecodingStrategy = .iso8601
-        let decoded = try decoder.decode(WidgetSnapshot.self, from: data)
-
-        #expect(decoded.entries.count == 1)
-        #expect(decoded.entries.first?.provider == .codex)
-        #expect(decoded.entries.first?.tokenUsage?.sessionTokens == 1200)
-        #expect(decoded.enabledProviders == [.codex, .claude])
-    }
-}

package/Tests/RunicTests/ZaiProviderTests.swift

@@ -1,59 +0,0 @@
-import Foundation
-import Testing
-@testable import RunicCore
-
-struct ZaiSettingsReaderTests {
-    @Test
-    func `api token reads from environment`() {
-        let token = ZaiSettingsReader.apiToken(environment: ["Z_AI_API_KEY": "abc123"])
-        #expect(token == "abc123")
-    }
-
-    @Test
-    func `api token strips quotes`() {
-        let token = ZaiSettingsReader.apiToken(environment: ["Z_AI_API_KEY": "\"token-xyz\""])
-        #expect(token == "token-xyz")
-    }
-}
-
-struct ZaiUsageSnapshotTests {
-    @Test
-    func `maps usage snapshot windows`() {
-        let reset = Date(timeIntervalSince1970: 123)
-        let tokenLimit = ZaiLimitEntry(
-            type: .tokensLimit,
-            unit: .hours,
-            number: 5,
-            usage: 100,
-            currentValue: 20,
-            remaining: 80,
-            percentage: 25,
-            usageDetails: [],
-            nextResetTime: reset)
-        let timeLimit = ZaiLimitEntry(
-            type: .timeLimit,
-            unit: .days,
-            number: 30,
-            usage: 200,
-            currentValue: 40,
-            remaining: 160,
-            percentage: 50,
-            usageDetails: [],
-            nextResetTime: nil)
-        let snapshot = ZaiUsageSnapshot(
-            tokenLimit: tokenLimit,
-            timeLimit: timeLimit,
-            planName: nil,
-            updatedAt: reset)
-
-        let usage = snapshot.toUsageSnapshot()
-
-        #expect(usage.primary.usedPercent == 20)
-        #expect(usage.primary.windowMinutes == 300)
-        #expect(usage.primary.resetsAt == reset)
-        #expect(usage.primary.resetDescription == "5 hours window")
-        #expect(usage.secondary?.usedPercent == 20)
-        #expect(usage.secondary?.resetDescription == "30 days window")
-        #expect(usage.zaiUsage?.tokenLimit?.usage == 100)
-    }
-}

package/Tests/RunicTests/ZaiTokenStoreTestSupport.swift

@@ -1,9 +0,0 @@
-@testable import Runic
-
-struct NoopZaiTokenStore: ZaiTokenStoring {
-    func loadToken() throws -> String? {
-        nil
-    }
-
-    func storeToken(_: String?) throws {}
-}

package/TestsLinux/PlatformGatingTests.swift

@@ -1,46 +0,0 @@
-import RunicCore
-import Testing
-
-@Suite
-struct PlatformGatingTests {
-    @Test
-    func claudeWebFetcher_isNotSupportedOnLinux() async {
-        #if os(Linux)
-        let error = await #expect(throws: ClaudeWebAPIFetcher.FetchError.self) {
-            _ = try await ClaudeWebAPIFetcher.fetchUsage()
-        }
-        let isExpectedError = error.map { thrown in
-            if case .notSupportedOnThisPlatform = thrown { return true }
-            return false
-        } ?? false
-        #expect(isExpectedError)
-        #else
-        #expect(Bool(true))
-        #endif
-    }
-
-    @Test
-    func claudeWebFetcher_hasSessionKey_isFalseOnLinux() {
-        #if os(Linux)
-        #expect(ClaudeWebAPIFetcher.hasSessionKey() == false)
-        #else
-        #expect(Bool(true))
-        #endif
-    }
-
-    @Test
-    func claudeWebFetcher_sessionKeyInfo_throwsOnLinux() {
-        #if os(Linux)
-        let error = #expect(throws: ClaudeWebAPIFetcher.FetchError.self) {
-            _ = try ClaudeWebAPIFetcher.sessionKeyInfo()
-        }
-        let isExpectedError = error.map { thrown in
-            if case .notSupportedOnThisPlatform = thrown { return true }
-            return false
-        } ?? false
-        #expect(isExpectedError)
-        #else
-        #expect(Bool(true))
-        #endif
-    }
-}