@sriinnu/runic 2.0.0 → 2.11.1

package/Tests/RunicTests/GeminiStatusProbeTests.swift

@@ -1,232 +0,0 @@
-import Foundation
-import RunicCore
-import Testing
-
-struct GeminiStatusProbeTests {
-    /// Sample /stats output from Gemini CLI (actual format with box-drawing chars)
-    static let sampleStatsOutput = """
-    │  Model Usage                            Reqs                  Usage left  │
-    │  ───────────────────────────────────────────────────────────────────────  │
-    │  gemini-2.5-flash                          -   99.8% (Resets in 20h 37m)  │
-    │  gemini-2.5-flash-lite                     -   99.8% (Resets in 20h 37m)  │
-    │  gemini-2.5-pro                            -      100.0% (Resets in 24h)  │
-    │  gemini-3-pro-preview                      -      100.0% (Resets in 24h)  │
-    """
-
-    // MARK: - Legacy CLI parsing tests (kept for fallback support)
-
-    @Test
-    func `parses minimum percent from multiple models`() throws {
-        let snap = try GeminiStatusProbe.parse(text: Self.sampleStatsOutput)
-        #expect(snap.dailyPercentLeft == 99.8)
-        #expect(snap.resetDescription == "Resets in 20h 37m")
-    }
-
-    @Test
-    func `parses lower percent correctly`() throws {
-        let output = """
-        │  Model Usage                                                  Reqs                  Usage left  │
-        │  gemini-2.5-flash                                               10       85.5% (Resets in 12h)  │
-        │  gemini-2.5-pro                                                  5       92.0% (Resets in 12h)  │
-        """
-        let snap = try GeminiStatusProbe.parse(text: output)
-        #expect(snap.dailyPercentLeft == 85.5)
-        #expect(snap.resetDescription == "Resets in 12h")
-    }
-
-    @Test
-    func `handles zero percent usage`() throws {
-        let output = """
-        │  gemini-2.5-flash                                               50        0.0% (Resets in 6h)  │
-        │  gemini-2.5-pro                                                 20       15.0% (Resets in 6h)  │
-        """
-        let snap = try GeminiStatusProbe.parse(text: output)
-        #expect(snap.dailyPercentLeft == 0.0)
-        #expect(snap.resetDescription == "Resets in 6h")
-    }
-
-    @Test
-    func `handles100 percent remaining`() throws {
-        let output = """
-        │  gemini-2.5-flash                                                -      100.0% (Resets in 24h)  │
-        """
-        let snap = try GeminiStatusProbe.parse(text: output)
-        #expect(snap.dailyPercentLeft == 100.0)
-    }
-
-    @Test
-    func `throws on empty output`() {
-        #expect(throws: GeminiStatusProbeError.self) {
-            try GeminiStatusProbe.parse(text: "")
-        }
-    }
-
-    @Test
-    func `throws on no usage data`() {
-        let output = """
-        Welcome to Gemini CLI!
-        Type /help for available commands.
-        """
-        #expect(throws: GeminiStatusProbeError.self) {
-            try GeminiStatusProbe.parse(text: output)
-        }
-    }
-
-    @Test
-    func `strips ANSI codes before parsing`() throws {
-        // swiftlint:disable:next line_length
-        let output = "\u{1B}[32m│\u{1B}[0m  gemini-2.5-flash                                                -       75.5% (Resets in 18h)  │"
-        let snap = try GeminiStatusProbe.parse(text: output)
-        #expect(snap.dailyPercentLeft == 75.5)
-    }
-
-    @Test
-    func `preserves raw text`() throws {
-        let snap = try GeminiStatusProbe.parse(text: Self.sampleStatsOutput)
-        #expect(snap.rawText == Self.sampleStatsOutput)
-        #expect(snap.accountEmail == nil) // Legacy parse doesn't extract email
-        #expect(snap.accountPlan == nil)
-    }
-
-    @Test
-    func `parses various reset descriptions`() throws {
-        let cases: [(String, String)] = [
-            ("Resets in 24h", "Resets in 24h"),
-            ("Resets in 1h 30m", "Resets in 1h 30m"),
-            ("Resets tomorrow", "Resets tomorrow"),
-        ]
-        for (resetStr, expected) in cases {
-            let output = """
-            │  gemini-2.5-flash                                                -       50.0% (\(resetStr))  │
-            """
-            let snap = try GeminiStatusProbe.parse(text: output)
-            #expect(snap.resetDescription == expected)
-        }
-    }
-
-    @Test
-    func `throws not logged in on auth prompt`() {
-        let authOutputs = [
-            "Waiting for auth... (Press ESC or CTRL+C to cancel)",
-            "Login with Google\nUse Gemini API key",
-            "Some preamble\nWaiting for auth\nMore text",
-        ]
-        for output in authOutputs {
-            #expect(throws: GeminiStatusProbeError.notLoggedIn) {
-                try GeminiStatusProbe.parse(text: output)
-            }
-        }
-    }
-
-    // MARK: - Model quota grouping tests
-
-    @Test
-    func `parses models into quota array`() throws {
-        let snap = try GeminiStatusProbe.parse(text: Self.sampleStatsOutput)
-        // Should parse multiple models (exact count may change as Google adds/removes models)
-        #expect(snap.modelQuotas.count >= 2)
-
-        // All model IDs should start with "gemini"
-        for quota in snap.modelQuotas {
-            #expect(quota.modelId.hasPrefix("gemini"))
-        }
-    }
-
-    @Test
-    func `lowest percent left returns minimum`() throws {
-        let snap = try GeminiStatusProbe.parse(text: Self.sampleStatsOutput)
-        // Flash models are 99.8%, Pro models are 100%, so min should be 99.8
-        #expect(snap.lowestPercentLeft == 99.8)
-    }
-
-    @Test
-    func `tier grouping by keyword`() throws {
-        // Test that flash/pro keyword filtering works (model names may change)
-        let snap = try GeminiStatusProbe.parse(text: Self.sampleStatsOutput)
-
-        let flashQuotas = snap.modelQuotas.filter { $0.modelId.contains("flash") }
-        let proQuotas = snap.modelQuotas.filter { $0.modelId.contains("pro") }
-
-        // Should have at least one of each tier in sample
-        #expect(!flashQuotas.isEmpty)
-        #expect(!proQuotas.isEmpty)
-    }
-
-    @Test
-    func `tier minimum calculation`() throws {
-        // Use controlled test data to verify min-per-tier logic
-        // Model names must start with "gemini-" to match the parser regex
-        let output = """
-        │  gemini-a-flash                            10       85.0% (Resets in 24h)  │
-        │  gemini-b-flash                             5       92.0% (Resets in 24h)  │
-        │  gemini-c-pro                               2       95.0% (Resets in 24h)  │
-        │  gemini-d-pro                               1       99.0% (Resets in 24h)  │
-        """
-        let snap = try GeminiStatusProbe.parse(text: output)
-
-        let flashQuotas = snap.modelQuotas.filter { $0.modelId.contains("flash") }
-        let proQuotas = snap.modelQuotas.filter { $0.modelId.contains("pro") }
-
-        let flashMin = flashQuotas.min(by: { $0.percentLeft < $1.percentLeft })
-        let proMin = proQuotas.min(by: { $0.percentLeft < $1.percentLeft })
-
-        #expect(flashMin?.percentLeft == 85.0)
-        #expect(proMin?.percentLeft == 95.0)
-    }
-
-    @Test
-    func `quotas have reset descriptions`() throws {
-        let snap = try GeminiStatusProbe.parse(text: Self.sampleStatsOutput)
-
-        // At least some quotas should have reset descriptions
-        let hasResets = snap.modelQuotas.contains { $0.resetDescription != nil }
-        #expect(hasResets)
-    }
-
-    @Test
-    func `to usage snapshot preserves model labels and tertiary window`() throws {
-        let output = """
-        │  gemini-2.5-pro                               2       40.0% (Resets in 6h)  │
-        │  gemini-2.5-flash                             5       65.0% (Resets in 3h)  │
-        │  gemini-2.5-flash-lite                        8       30.0% (Resets in 1h)  │
-        """
-        let snapshot = try GeminiStatusProbe.parse(text: output)
-        let usage = snapshot.toUsageSnapshot()
-        #expect(Int(usage.primary.usedPercent.rounded()) == 60)
-        #expect(usage.primary.label == "gemini 2.5 pro")
-        #expect(Int(usage.secondary?.usedPercent.rounded() ?? -1) == 70)
-        #expect(usage.secondary?.label == "gemini 2.5 flash lite")
-        #expect(Int(usage.tertiary?.usedPercent.rounded() ?? -1) == 35)
-        #expect(usage.tertiary?.label == "gemini 2.5 flash")
-    }
-
-    @Test
-    func `to usage snapshot falls back when pro tier is missing`() throws {
-        let output = """
-        │  gemini-2.5-flash                             2       90.0% (Resets in 6h)  │
-        │  gemini-2.5-flash-lite                        3       25.0% (Resets in 6h)  │
-        """
-        let snapshot = try GeminiStatusProbe.parse(text: output)
-        let usage = snapshot.toUsageSnapshot()
-        #expect(Int(usage.primary.usedPercent.rounded()) == 75)
-        #expect(usage.primary.label == "gemini 2.5 flash lite")
-    }
-
-    // MARK: - Live API test
-
-    @Test
-    func `live gemini fetch`() async throws {
-        guard ProcessInfo.processInfo.environment["LIVE_GEMINI_FETCH"] == "1" else {
-            return
-        }
-        let probe = GeminiStatusProbe()
-        let snap = try await probe.fetch()
-        print(
-            """
-            Live Gemini usage (via API):
-            models: \(snap.modelQuotas.map { "\($0.modelId): \($0.percentLeft)%" }.joined(separator: ", "))
-            lowest: \(snap.lowestPercentLeft ?? -1)% left
-            """)
-        #expect(!snap.modelQuotas.isEmpty)
-    }
-}

package/Tests/RunicTests/GeminiTestEnvironment.swift

@@ -1,87 +0,0 @@
-import Foundation
-
-struct GeminiTestEnvironment {
-    let homeURL: URL
-    private let geminiDir: URL
-
-    init() throws {
-        let root = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
-        try FileManager.default.createDirectory(at: root, withIntermediateDirectories: true)
-        let geminiDir = root.appendingPathComponent(".gemini")
-        try FileManager.default.createDirectory(at: geminiDir, withIntermediateDirectories: true)
-        self.homeURL = root
-        self.geminiDir = geminiDir
-    }
-
-    func cleanup() {
-        try? FileManager.default.removeItem(at: self.homeURL)
-    }
-
-    func writeSettings(authType: String) throws {
-        let payload: [String: Any] = [
-            "security": [
-                "auth": [
-                    "selectedType": authType,
-                ],
-            ],
-        ]
-        let data = try JSONSerialization.data(withJSONObject: payload)
-        try data.write(to: self.geminiDir.appendingPathComponent("settings.json"), options: .atomic)
-    }
-
-    func writeCredentials(accessToken: String, refreshToken: String?, expiry: Date, idToken: String?) throws {
-        var payload: [String: Any] = [
-            "access_token": accessToken,
-            "expiry_date": expiry.timeIntervalSince1970 * 1000,
-        ]
-        if let refreshToken { payload["refresh_token"] = refreshToken }
-        if let idToken { payload["id_token"] = idToken }
-        let data = try JSONSerialization.data(withJSONObject: payload)
-        try data.write(to: self.geminiDir.appendingPathComponent("oauth_creds.json"), options: .atomic)
-    }
-
-    func readCredentials() throws -> [String: Any] {
-        let url = self.geminiDir.appendingPathComponent("oauth_creds.json")
-        let data = try Data(contentsOf: url)
-        let object = try JSONSerialization.jsonObject(with: data)
-        return object as? [String: Any] ?? [:]
-    }
-
-    func writeFakeGeminiCLI(includeOAuth: Bool = true) throws -> URL {
-        let base = self.homeURL.appendingPathComponent("gemini-cli")
-        let binDir = base.appendingPathComponent("bin")
-        try FileManager.default.createDirectory(at: binDir, withIntermediateDirectories: true)
-
-        let oauthPath = base
-            .appendingPathComponent("lib")
-            .appendingPathComponent("node_modules")
-            .appendingPathComponent("@google")
-            .appendingPathComponent("gemini-cli")
-            .appendingPathComponent("node_modules")
-            .appendingPathComponent("@google")
-            .appendingPathComponent("gemini-cli-core")
-            .appendingPathComponent("dist")
-            .appendingPathComponent("src")
-            .appendingPathComponent("code_assist")
-            .appendingPathComponent("oauth2.js")
-
-        if includeOAuth {
-            try FileManager.default.createDirectory(
-                at: oauthPath.deletingLastPathComponent(),
-                withIntermediateDirectories: true)
-
-            let oauthContent = """
-            const OAUTH_CLIENT_ID = 'test-client-id';
-            const OAUTH_CLIENT_SECRET = 'test-client-secret';
-            """
-            try oauthContent.write(to: oauthPath, atomically: true, encoding: .utf8)
-        }
-
-        let geminiBinary = binDir.appendingPathComponent("gemini")
-        try "#!/bin/bash\nexit 0\n".write(to: geminiBinary, atomically: true, encoding: .utf8)
-        try FileManager.default.setAttributes(
-            [.posixPermissions: 0o755],
-            ofItemAtPath: geminiBinary.path)
-        return geminiBinary
-    }
-}

package/Tests/RunicTests/GoogleWorkspaceStatusTests.swift

@@ -1,72 +0,0 @@
-import Foundation
-import Testing
-@testable import Runic
-
-@MainActor
-struct GoogleWorkspaceStatusTests {
-    private let productID = "npdyhgECDJ6tB66MxXyo"
-
-    @Test
-    func `parse workspace status selects worst incident`() throws {
-        let data = Data(#"""
-        [
-          {
-            "id": "inc-1",
-            "begin": "2025-12-02T09:00:00+00:00",
-            "end": null,
-            "affected_products": [
-              {"title": "Gemini", "id": "npdyhgECDJ6tB66MxXyo"}
-            ],
-            "most_recent_update": {
-              "when": "2025-12-02T10:00:00+00:00",
-              "status": "SERVICE_INFORMATION",
-              "text": "**Summary**\nMinor issue.\n"
-            }
-          },
-          {
-            "id": "inc-2",
-            "begin": "2025-12-02T11:00:00+00:00",
-            "end": null,
-            "affected_products": [
-              {"title": "Gemini", "id": "npdyhgECDJ6tB66MxXyo"}
-            ],
-            "most_recent_update": {
-              "when": "2025-12-02T12:00:00+00:00",
-              "status": "SERVICE_OUTAGE",
-              "text": "**Summary**\nGemini API error.\n"
-            }
-          }
-        ]
-        """#.utf8)
-
-        let status = try UsageStore.parseGoogleWorkspaceStatus(data: data, productID: self.productID)
-        #expect(status.indicator == .critical)
-        #expect(status.description == "Gemini API error.")
-        #expect(status.updatedAt != nil)
-    }
-
-    @Test
-    func `parse workspace status ignores resolved incidents`() throws {
-        let data = Data(#"""
-        [
-          {
-            "id": "inc-3",
-            "begin": "2025-12-02T08:00:00+00:00",
-            "end": "2025-12-02T09:00:00+00:00",
-            "affected_products": [
-              {"title": "Gemini", "id": "npdyhgECDJ6tB66MxXyo"}
-            ],
-            "most_recent_update": {
-              "when": "2025-12-02T09:00:00+00:00",
-              "status": "AVAILABLE",
-              "text": "**Summary**\nResolved.\n"
-            }
-          }
-        ]
-        """#.utf8)
-
-        let status = try UsageStore.parseGoogleWorkspaceStatus(data: data, productID: self.productID)
-        #expect(status.indicator == .none)
-        #expect(status.description == nil)
-    }
-}

package/Tests/RunicTests/InstallOriginTests.swift

@@ -1,17 +0,0 @@
-import Foundation
-import Testing
-@testable import Runic
-
-struct InstallOriginTests {
-    @Test
-    func `detects homebrew caskroom`() {
-        #expect(
-            InstallOrigin
-                .isHomebrewCask(
-                    appBundleURL: URL(fileURLWithPath: "/opt/homebrew/Caskroom/runic/1.0.0/Runic.app")))
-        #expect(
-            InstallOrigin
-                .isHomebrewCask(appBundleURL: URL(fileURLWithPath: "/usr/local/Caskroom/runic/1.0.0/Runic.app")))
-        #expect(!InstallOrigin.isHomebrewCask(appBundleURL: URL(fileURLWithPath: "/Applications/Runic.app")))
-    }
-}

package/Tests/RunicTests/KeyboardShortcutsBundleTests.swift

@@ -1,9 +0,0 @@
-import KeyboardShortcuts
-import Testing
-
-@MainActor
-struct KeyboardShortcutsBundleTests {
-    @Test func `recorder initializes without crashing`() {
-        _ = KeyboardShortcuts.RecorderCocoa(for: .init("test.keyboardshortcuts.bundle"))
-    }
-}

package/Tests/RunicTests/LiveAccountTests.swift

@@ -1,24 +0,0 @@
-import Foundation
-import RunicCore
-import Testing
-import XCTest
-@testable import Runic
-
-@Suite(.serialized)
-struct LiveAccountTests {
-    @Test(.disabled("Set LIVE_TEST=1 to run live Codex account checks."))
-    func `codex account email is present`() async throws {
-        guard ProcessInfo.processInfo.environment["LIVE_TEST"] == "1" else { return }
-
-        let fetcher = UsageFetcher()
-        let usage = try await fetcher.loadLatestUsage()
-        guard let email = usage.accountEmail(for: .codex) else {
-            Issue.record("Account email missing from RPC usage snapshot")
-            return
-        }
-
-        let pattern = #"^[^\s@]+@[^\s@]+\.[^\s@]+$"#
-        let regex = try Regex(pattern)
-        #expect(email.contains(regex), "Email did not match pattern: \(email)")
-    }
-}

package/Tests/RunicTests/LoadingPatternTests.swift

@@ -1,34 +0,0 @@
-import Foundation
-import Testing
-@testable import Runic
-
-struct LoadingPatternTests {
-    @Test
-    func `values stay within bounds`() {
-        for pattern in LoadingPattern.allCases {
-            for phase in stride(from: 0.0, through: Double.pi * 2, by: Double.pi / 6) {
-                let v = pattern.value(phase: phase)
-                #expect(v >= 0 && v <= 100, "pattern \(pattern) out of bounds at phase \(phase)")
-            }
-        }
-    }
-
-    @Test
-    func `knight rider ping pongs`() {
-        let pattern = LoadingPattern.knightRider
-        let mid = pattern.value(phase: 0) // sin 0 = 0 => 50
-        let min = pattern.value(phase: -Double.pi / 2) // sin -pi/2 = -1 => 0
-        let max = pattern.value(phase: Double.pi / 2) // sin pi/2 = 1 => 100
-        #expect(min <= mid && mid <= max)
-        #expect(min == 0)
-        #expect(max == 100)
-    }
-
-    @Test
-    func `secondary offset differs`() {
-        let pattern = LoadingPattern.cylon
-        let primary = pattern.value(phase: 0)
-        let secondary = pattern.value(phase: pattern.secondaryOffset)
-        #expect(primary != secondary, "secondary should be offset from primary")
-    }
-}