@sriinnu/runic 2.0.0 → 2.11.1

package/Tests/RunicTests/CostUsageScannerTests.swift

@@ -1,698 +0,0 @@
-import Foundation
-import Testing
-@testable import RunicCore
-
-struct CostUsageScannerTests {
-    @Test
-    func `codex daily report parses token counts and caches`() throws {
-        let env = try CostUsageTestEnvironment()
-        defer { env.cleanup() }
-
-        let day = try env.makeLocalNoon(year: 2025, month: 12, day: 20)
-        let iso0 = env.isoString(for: day)
-        let iso1 = env.isoString(for: day.addingTimeInterval(1))
-        let iso2 = env.isoString(for: day.addingTimeInterval(2))
-
-        let model = "openai/gpt-5.2-codex"
-        let turnContext: [String: Any] = [
-            "type": "turn_context",
-            "timestamp": iso0,
-            "payload": [
-                "model": model,
-            ],
-        ]
-        let firstTokenCount: [String: Any] = [
-            "type": "event_msg",
-            "timestamp": iso1,
-            "payload": [
-                "type": "token_count",
-                "info": [
-                    "total_token_usage": [
-                        "input_tokens": 100,
-                        "cached_input_tokens": 20,
-                        "output_tokens": 10,
-                    ],
-                    "model": model,
-                ],
-            ],
-        ]
-
-        let fileURL = try env.writeCodexSessionFile(
-            day: day,
-            filename: "session.jsonl",
-            contents: env.jsonl([turnContext, firstTokenCount]))
-
-        var options = CostUsageScanner.Options(
-            codexSessionsRoot: env.codexSessionsRoot,
-            claudeProjectsRoots: nil,
-            cacheRoot: env.cacheRoot)
-        options.refreshMinIntervalSeconds = 0
-
-        let first = CostUsageScanner.loadDailyReport(
-            provider: .codex,
-            since: day,
-            until: day,
-            now: day,
-            options: options)
-        #expect(first.data.count == 1)
-        #expect(first.data[0].modelsUsed == ["gpt-5.2"])
-        #expect(first.data[0].totalTokens == 110)
-        #expect((first.data[0].costUSD ?? 0) > 0)
-
-        let secondTokenCount: [String: Any] = [
-            "type": "event_msg",
-            "timestamp": iso2,
-            "payload": [
-                "type": "token_count",
-                "info": [
-                    "total_token_usage": [
-                        "input_tokens": 160,
-                        "cached_input_tokens": 40,
-                        "output_tokens": 16,
-                    ],
-                    "model": model,
-                ],
-            ],
-        ]
-        try env.jsonl([turnContext, firstTokenCount, secondTokenCount])
-            .write(to: fileURL, atomically: true, encoding: .utf8)
-
-        let second = CostUsageScanner.loadDailyReport(
-            provider: .codex,
-            since: day,
-            until: day,
-            now: day,
-            options: options)
-        #expect(second.data.count == 1)
-        #expect(second.data[0].totalTokens == 176)
-        #expect((second.data[0].costUSD ?? 0) > (first.data[0].costUSD ?? 0))
-    }
-
-    @Test
-    func `claude daily report parses usage and caches`() throws {
-        let env = try CostUsageTestEnvironment()
-        defer { env.cleanup() }
-
-        let day = try env.makeLocalNoon(year: 2025, month: 12, day: 20)
-        let iso0 = env.isoString(for: day)
-
-        let assistant: [String: Any] = [
-            "type": "assistant",
-            "timestamp": iso0,
-            "message": [
-                "model": "claude-sonnet-4-20250514",
-                "usage": [
-                    "input_tokens": 200,
-                    "cache_creation_input_tokens": 50,
-                    "cache_read_input_tokens": 25,
-                    "output_tokens": 80,
-                ],
-            ],
-        ]
-        _ = try env.writeClaudeProjectFile(
-            relativePath: "project-a/session-a.jsonl",
-            contents: env.jsonl([assistant]))
-
-        var options = CostUsageScanner.Options(
-            codexSessionsRoot: nil,
-            claudeProjectsRoots: [env.claudeProjectsRoot],
-            cacheRoot: env.cacheRoot)
-        options.refreshMinIntervalSeconds = 0
-
-        let report = CostUsageScanner.loadDailyReport(
-            provider: .claude,
-            since: day,
-            until: day,
-            now: day,
-            options: options)
-        #expect(report.data.count == 1)
-        #expect(report.data[0].modelsUsed == ["claude-sonnet-4-20250514"])
-        #expect(report.data[0].inputTokens == 200)
-        #expect(report.data[0].cacheCreationTokens == 50)
-        #expect(report.data[0].cacheReadTokens == 25)
-        #expect(report.data[0].outputTokens == 80)
-        #expect(report.data[0].totalTokens == 355)
-        #expect((report.data[0].costUSD ?? 0) > 0)
-    }
-
-    @Test
-    func `claude parses large lines with usage at tail`() throws {
-        let env = try CostUsageTestEnvironment()
-        defer { env.cleanup() }
-
-        let day = try env.makeLocalNoon(year: 2025, month: 12, day: 28)
-        let iso0 = env.isoString(for: day)
-        let largeText = String(repeating: "a", count: 70000)
-
-        let assistant: [String: Any] = [
-            "type": "assistant",
-            "timestamp": iso0,
-            "message": [
-                "model": "claude-sonnet-4-20250514",
-                "content": [
-                    ["type": "text", "text": largeText],
-                ],
-                "usage": [
-                    "input_tokens": 3714,
-                    "output_tokens": 1,
-                ],
-            ],
-        ]
-        _ = try env.writeClaudeProjectFile(
-            relativePath: "project-a/large-line.jsonl",
-            contents: env.jsonl([assistant]))
-
-        var options = CostUsageScanner.Options(
-            codexSessionsRoot: nil,
-            claudeProjectsRoots: [env.claudeProjectsRoot],
-            cacheRoot: env.cacheRoot)
-        options.refreshMinIntervalSeconds = 0
-
-        let report = CostUsageScanner.loadDailyReport(
-            provider: .claude,
-            since: day,
-            until: day,
-            now: day,
-            options: options)
-        #expect(report.data.count == 1)
-        #expect(report.data[0].inputTokens == 3714)
-        #expect(report.data[0].outputTokens == 1)
-        #expect(report.data[0].totalTokens == 3715)
-    }
-
-    @Test
-    func `claude daily report refreshes when file changes`() throws {
-        let env = try CostUsageTestEnvironment()
-        defer { env.cleanup() }
-
-        let day = try env.makeLocalNoon(year: 2025, month: 12, day: 20)
-        let iso0 = env.isoString(for: day)
-        let iso1 = env.isoString(for: day.addingTimeInterval(1))
-
-        let model = "claude-sonnet-4-20250514"
-        let first: [String: Any] = [
-            "type": "assistant",
-            "timestamp": iso0,
-            "message": [
-                "model": model,
-                "usage": [
-                    "input_tokens": 200,
-                    "cache_creation_input_tokens": 50,
-                    "cache_read_input_tokens": 25,
-                    "output_tokens": 80,
-                ],
-            ],
-        ]
-        let fileURL = try env.writeClaudeProjectFile(
-            relativePath: "project-a/session-a.jsonl",
-            contents: env.jsonl([first]))
-
-        var options = CostUsageScanner.Options(
-            codexSessionsRoot: nil,
-            claudeProjectsRoots: [env.claudeProjectsRoot],
-            cacheRoot: env.cacheRoot)
-        options.refreshMinIntervalSeconds = 0
-
-        let firstReport = CostUsageScanner.loadDailyReport(
-            provider: .claude,
-            since: day,
-            until: day,
-            now: day,
-            options: options)
-        #expect(firstReport.data.first?.totalTokens == 355)
-
-        let second: [String: Any] = [
-            "type": "assistant",
-            "timestamp": iso1,
-            "message": [
-                "model": model,
-                "usage": [
-                    "input_tokens": 40,
-                    "cache_creation_input_tokens": 10,
-                    "cache_read_input_tokens": 5,
-                    "output_tokens": 20,
-                ],
-            ],
-        ]
-        try env.jsonl([first, second]).write(to: fileURL, atomically: true, encoding: .utf8)
-
-        let secondReport = CostUsageScanner.loadDailyReport(
-            provider: .claude,
-            since: day,
-            until: day,
-            now: day,
-            options: options)
-        #expect(secondReport.data.first?.totalTokens == 430)
-    }
-
-    @Test
-    func `codex incremental parsing uses previous totals`() throws {
-        let env = try CostUsageTestEnvironment()
-        defer { env.cleanup() }
-
-        let day = try env.makeLocalNoon(year: 2025, month: 12, day: 20)
-        let iso0 = env.isoString(for: day)
-        let iso1 = env.isoString(for: day.addingTimeInterval(1))
-        let iso2 = env.isoString(for: day.addingTimeInterval(2))
-
-        let model = "openai/gpt-5.2-codex"
-        let normalized = CostUsagePricing.normalizeCodexModel(model)
-        let turnContext: [String: Any] = [
-            "type": "turn_context",
-            "timestamp": iso0,
-            "payload": [
-                "model": model,
-            ],
-        ]
-        let firstTokenCount: [String: Any] = [
-            "type": "event_msg",
-            "timestamp": iso1,
-            "payload": [
-                "type": "token_count",
-                "info": [
-                    "total_token_usage": [
-                        "input_tokens": 100,
-                        "cached_input_tokens": 20,
-                        "output_tokens": 10,
-                    ],
-                    "model": model,
-                ],
-            ],
-        ]
-
-        let fileURL = try env.writeCodexSessionFile(
-            day: day,
-            filename: "session.jsonl",
-            contents: env.jsonl([turnContext, firstTokenCount]))
-
-        let range = CostUsageScanner.CostUsageDayRange(since: day, until: day)
-        let first = CostUsageScanner.parseCodexFile(fileURL: fileURL, range: range)
-        #expect(first.parsedBytes > 0)
-        #expect(first.lastTotals?.input == 100)
-        #expect(first.lastTotals?.cached == 20)
-        #expect(first.lastTotals?.output == 10)
-
-        let secondTokenCount: [String: Any] = [
-            "type": "event_msg",
-            "timestamp": iso2,
-            "payload": [
-                "type": "token_count",
-                "info": [
-                    "total_token_usage": [
-                        "input_tokens": 160,
-                        "cached_input_tokens": 40,
-                        "output_tokens": 16,
-                    ],
-                    "model": model,
-                ],
-            ],
-        ]
-        try env.jsonl([turnContext, firstTokenCount, secondTokenCount])
-            .write(to: fileURL, atomically: true, encoding: .utf8)
-
-        let delta = CostUsageScanner.parseCodexFile(
-            fileURL: fileURL,
-            range: range,
-            startOffset: first.parsedBytes,
-            initialModel: first.lastModel,
-            initialTotals: first.lastTotals)
-        let dayKey = CostUsageScanner.CostUsageDayRange.dayKey(from: day)
-        let packed = delta.days[dayKey]?[normalized] ?? []
-        #expect(packed.count >= 3)
-        #expect(packed[0] == 60)
-        #expect(packed[1] == 20)
-        #expect(packed[2] == 6)
-    }
-
-    @Test
-    func `claude incremental parsing reads appended lines only`() throws {
-        let env = try CostUsageTestEnvironment()
-        defer { env.cleanup() }
-
-        let day = try env.makeLocalNoon(year: 2025, month: 12, day: 20)
-        let iso0 = env.isoString(for: day)
-        let iso1 = env.isoString(for: day.addingTimeInterval(1))
-
-        let model = "claude-sonnet-4-20250514"
-        let normalized = CostUsagePricing.normalizeClaudeModel(model)
-        let first: [String: Any] = [
-            "type": "assistant",
-            "timestamp": iso0,
-            "message": [
-                "model": model,
-                "usage": [
-                    "input_tokens": 200,
-                    "cache_creation_input_tokens": 50,
-                    "cache_read_input_tokens": 25,
-                    "output_tokens": 80,
-                ],
-            ],
-        ]
-        let fileURL = try env.writeClaudeProjectFile(
-            relativePath: "project-a/session-a.jsonl",
-            contents: env.jsonl([first]))
-
-        let range = CostUsageScanner.CostUsageDayRange(since: day, until: day)
-        let firstParse = CostUsageScanner.parseClaudeFile(fileURL: fileURL, range: range)
-        #expect(firstParse.parsedBytes > 0)
-
-        let second: [String: Any] = [
-            "type": "assistant",
-            "timestamp": iso1,
-            "message": [
-                "model": model,
-                "usage": [
-                    "input_tokens": 40,
-                    "cache_creation_input_tokens": 10,
-                    "cache_read_input_tokens": 5,
-                    "output_tokens": 20,
-                ],
-            ],
-        ]
-        try env.jsonl([first, second]).write(to: fileURL, atomically: true, encoding: .utf8)
-
-        let delta = CostUsageScanner.parseClaudeFile(
-            fileURL: fileURL,
-            range: range,
-            startOffset: firstParse.parsedBytes)
-        let dayKey = CostUsageScanner.CostUsageDayRange.dayKey(from: day)
-        let packed = delta.days[dayKey]?[normalized] ?? []
-        #expect(packed.count >= 4)
-        #expect(packed[0] == 40)
-        #expect(packed[1] == 5)
-        #expect(packed[2] == 10)
-        #expect(packed[3] == 20)
-    }
-
-    @Test
-    func `day key from timestamp matches ISO parsing`() {
-        let timestamps = [
-            "2025-12-20T23:59:59Z",
-            "2025-12-20T23:59:59+02:00",
-        ]
-
-        for ts in timestamps {
-            let expected = CostUsageScanner.dayKeyFromParsedISO(ts)
-            let fast = CostUsageScanner.dayKeyFromTimestamp(ts)
-            #expect(fast == expected)
-        }
-    }
-
-    @Test
-    func `claude deduplicates streaming chunks`() throws {
-        let env = try CostUsageTestEnvironment()
-        defer { env.cleanup() }
-
-        let day = try env.makeLocalNoon(year: 2025, month: 12, day: 20)
-        let iso0 = env.isoString(for: day)
-        let iso1 = env.isoString(for: day.addingTimeInterval(1))
-        let iso2 = env.isoString(for: day.addingTimeInterval(2))
-
-        let model = "claude-sonnet-4-20250514"
-        let messageId = "msg_01ABC123"
-        let requestId = "req_01XYZ789"
-
-        // Streaming emits multiple chunks with same message.id + requestId.
-        // Each chunk has cumulative usage, not delta.
-        let chunk1: [String: Any] = [
-            "type": "assistant",
-            "timestamp": iso0,
-            "requestId": requestId,
-            "message": [
-                "id": messageId,
-                "model": model,
-                "usage": [
-                    "input_tokens": 100,
-                    "cache_creation_input_tokens": 50,
-                    "cache_read_input_tokens": 25,
-                    "output_tokens": 10,
-                ],
-            ],
-        ]
-        let chunk2: [String: Any] = [
-            "type": "assistant",
-            "timestamp": iso1,
-            "requestId": requestId,
-            "message": [
-                "id": messageId,
-                "model": model,
-                "usage": [
-                    "input_tokens": 100,
-                    "cache_creation_input_tokens": 50,
-                    "cache_read_input_tokens": 25,
-                    "output_tokens": 10,
-                ],
-            ],
-        ]
-        let chunk3: [String: Any] = [
-            "type": "assistant",
-            "timestamp": iso2,
-            "requestId": requestId,
-            "message": [
-                "id": messageId,
-                "model": model,
-                "usage": [
-                    "input_tokens": 100,
-                    "cache_creation_input_tokens": 50,
-                    "cache_read_input_tokens": 25,
-                    "output_tokens": 10,
-                ],
-            ],
-        ]
-
-        _ = try env.writeClaudeProjectFile(
-            relativePath: "project-a/session-a.jsonl",
-            contents: env.jsonl([chunk1, chunk2, chunk3]))
-
-        var options = CostUsageScanner.Options(
-            codexSessionsRoot: nil,
-            claudeProjectsRoots: [env.claudeProjectsRoot],
-            cacheRoot: env.cacheRoot)
-        options.refreshMinIntervalSeconds = 0
-
-        let report = CostUsageScanner.loadDailyReport(
-            provider: .claude,
-            since: day,
-            until: day,
-            now: day,
-            options: options)
-
-        // Should only count once, not 3x.
-        #expect(report.data.count == 1)
-        #expect(report.data[0].inputTokens == 100)
-        #expect(report.data[0].cacheCreationTokens == 50)
-        #expect(report.data[0].cacheReadTokens == 25)
-        #expect(report.data[0].outputTokens == 10)
-        #expect(report.data[0].totalTokens == 185)
-    }
-
-    @Test
-    func `claude counts entries without ids as separate`() throws {
-        let env = try CostUsageTestEnvironment()
-        defer { env.cleanup() }
-
-        let day = try env.makeLocalNoon(year: 2025, month: 12, day: 20)
-        let iso0 = env.isoString(for: day)
-        let iso1 = env.isoString(for: day.addingTimeInterval(1))
-
-        let model = "claude-sonnet-4-20250514"
-
-        // Entries without message.id or requestId should still be counted
-        // (fallback for older log formats).
-        let entry1: [String: Any] = [
-            "type": "assistant",
-            "timestamp": iso0,
-            "message": [
-                "model": model,
-                "usage": [
-                    "input_tokens": 100,
-                    "cache_creation_input_tokens": 0,
-                    "cache_read_input_tokens": 0,
-                    "output_tokens": 50,
-                ],
-            ],
-        ]
-        let entry2: [String: Any] = [
-            "type": "assistant",
-            "timestamp": iso1,
-            "message": [
-                "model": model,
-                "usage": [
-                    "input_tokens": 200,
-                    "cache_creation_input_tokens": 0,
-                    "cache_read_input_tokens": 0,
-                    "output_tokens": 100,
-                ],
-            ],
-        ]
-
-        _ = try env.writeClaudeProjectFile(
-            relativePath: "project-a/session-a.jsonl",
-            contents: env.jsonl([entry1, entry2]))
-
-        var options = CostUsageScanner.Options(
-            codexSessionsRoot: nil,
-            claudeProjectsRoots: [env.claudeProjectsRoot],
-            cacheRoot: env.cacheRoot)
-        options.refreshMinIntervalSeconds = 0
-
-        let report = CostUsageScanner.loadDailyReport(
-            provider: .claude,
-            since: day,
-            until: day,
-            now: day,
-            options: options)
-
-        // Both entries should be counted since no IDs to dedupe.
-        #expect(report.data.count == 1)
-        #expect(report.data[0].inputTokens == 300)
-        #expect(report.data[0].outputTokens == 150)
-        #expect(report.data[0].totalTokens == 450)
-    }
-
-    @Test
-    func `claude counts different request ids separately`() throws {
-        let env = try CostUsageTestEnvironment()
-        defer { env.cleanup() }
-
-        let day = try env.makeLocalNoon(year: 2025, month: 12, day: 20)
-        let iso0 = env.isoString(for: day)
-        let iso1 = env.isoString(for: day.addingTimeInterval(1))
-
-        let model = "claude-sonnet-4-20250514"
-        let messageId = "msg_01ABC123"
-
-        let entry1: [String: Any] = [
-            "type": "assistant",
-            "timestamp": iso0,
-            "requestId": "req_01AAA",
-            "message": [
-                "id": messageId,
-                "model": model,
-                "usage": [
-                    "input_tokens": 10,
-                    "cache_creation_input_tokens": 0,
-                    "cache_read_input_tokens": 0,
-                    "output_tokens": 5,
-                ],
-            ],
-        ]
-        let entry2: [String: Any] = [
-            "type": "assistant",
-            "timestamp": iso1,
-            "requestId": "req_01BBB",
-            "message": [
-                "id": messageId,
-                "model": model,
-                "usage": [
-                    "input_tokens": 20,
-                    "cache_creation_input_tokens": 0,
-                    "cache_read_input_tokens": 0,
-                    "output_tokens": 10,
-                ],
-            ],
-        ]
-
-        _ = try env.writeClaudeProjectFile(
-            relativePath: "project-a/session-a.jsonl",
-            contents: env.jsonl([entry1, entry2]))
-
-        var options = CostUsageScanner.Options(
-            codexSessionsRoot: nil,
-            claudeProjectsRoots: [env.claudeProjectsRoot],
-            cacheRoot: env.cacheRoot)
-        options.refreshMinIntervalSeconds = 0
-
-        let report = CostUsageScanner.loadDailyReport(
-            provider: .claude,
-            since: day,
-            until: day,
-            now: day,
-            options: options)
-
-        #expect(report.data.count == 1)
-        #expect(report.data[0].inputTokens == 30)
-        #expect(report.data[0].outputTokens == 15)
-        #expect(report.data[0].totalTokens == 45)
-    }
-}
-
-private struct CostUsageTestEnvironment {
-    let root: URL
-    let cacheRoot: URL
-    let codexSessionsRoot: URL
-    let claudeProjectsRoot: URL
-
-    init() throws {
-        let root = FileManager.default.temporaryDirectory.appendingPathComponent(
-            "runic-cost-usage-\(UUID().uuidString)",
-            isDirectory: true)
-        try FileManager.default.createDirectory(at: root, withIntermediateDirectories: true)
-        self.root = root
-        self.cacheRoot = root.appendingPathComponent("cache", isDirectory: true)
-        self.codexSessionsRoot = root.appendingPathComponent("codex-sessions", isDirectory: true)
-        self.claudeProjectsRoot = root.appendingPathComponent("claude-projects", isDirectory: true)
-        try FileManager.default.createDirectory(at: self.cacheRoot, withIntermediateDirectories: true)
-        try FileManager.default.createDirectory(at: self.codexSessionsRoot, withIntermediateDirectories: true)
-        try FileManager.default.createDirectory(at: self.claudeProjectsRoot, withIntermediateDirectories: true)
-    }
-
-    func cleanup() {
-        try? FileManager.default.removeItem(at: self.root)
-    }
-
-    func makeLocalNoon(year: Int, month: Int, day: Int) throws -> Date {
-        var comps = DateComponents()
-        comps.calendar = Calendar.current
-        comps.timeZone = TimeZone.current
-        comps.year = year
-        comps.month = month
-        comps.day = day
-        comps.hour = 12
-        comps.minute = 0
-        comps.second = 0
-        guard let date = comps.date else { throw NSError(domain: "CostUsageTestEnvironment", code: 1) }
-        return date
-    }
-
-    func isoString(for date: Date) -> String {
-        let fmt = ISO8601DateFormatter()
-        fmt.formatOptions = [.withInternetDateTime]
-        return fmt.string(from: date)
-    }
-
-    func writeCodexSessionFile(day: Date, filename: String, contents: String) throws -> URL {
-        let comps = Calendar.current.dateComponents([.year, .month, .day], from: day)
-        let y = String(format: "%04d", comps.year ?? 1970)
-        let m = String(format: "%02d", comps.month ?? 1)
-        let d = String(format: "%02d", comps.day ?? 1)
-
-        let dir = self.codexSessionsRoot
-            .appendingPathComponent(y, isDirectory: true)
-            .appendingPathComponent(m, isDirectory: true)
-            .appendingPathComponent(d, isDirectory: true)
-        try FileManager.default.createDirectory(at: dir, withIntermediateDirectories: true)
-
-        let url = dir.appendingPathComponent(filename, isDirectory: false)
-        try contents.write(to: url, atomically: true, encoding: .utf8)
-        return url
-    }
-
-    func writeClaudeProjectFile(relativePath: String, contents: String) throws -> URL {
-        let url = self.claudeProjectsRoot.appendingPathComponent(relativePath, isDirectory: false)
-        try FileManager.default.createDirectory(at: url.deletingLastPathComponent(), withIntermediateDirectories: true)
-        try contents.write(to: url, atomically: true, encoding: .utf8)
-        return url
-    }
-
-    func jsonl(_ objects: [Any]) throws -> String {
-        let lines = try objects.map { obj in
-            let data = try JSONSerialization.data(withJSONObject: obj)
-            guard let text = String(bytes: data, encoding: .utf8) else {
-                throw NSError(domain: "CostUsageTestEnvironment", code: 2)
-            }
-            return text
-        }
-        return lines.joined(separator: "\n") + "\n"
-    }
-}