@sriinnu/runic 1.0.0

package/Sources/RunicCore/Vendored/CostUsage/CostUsageScanner.swift

@@ -0,0 +1,589 @@
+import Foundation
+
+enum CostUsageScanner {
+    struct Options: Sendable {
+        var codexSessionsRoot: URL?
+        var claudeProjectsRoots: [URL]?
+        var cacheRoot: URL?
+        var refreshMinIntervalSeconds: TimeInterval = 60
+        // Force a full rescan, ignoring per-file cache and incremental offsets.
+        var forceRescan: Bool = false
+
+        init(
+            codexSessionsRoot: URL? = nil,
+            claudeProjectsRoots: [URL]? = nil,
+            cacheRoot: URL? = nil,
+            forceRescan: Bool = false)
+        {
+            self.codexSessionsRoot = codexSessionsRoot
+            self.claudeProjectsRoots = claudeProjectsRoots
+            self.cacheRoot = cacheRoot
+            self.forceRescan = forceRescan
+        }
+    }
+
+    struct CodexParseResult: Sendable {
+        let days: [String: [String: [Int]]]
+        let parsedBytes: Int64
+        let lastModel: String?
+        let lastTotals: CostUsageCodexTotals?
+    }
+
+    struct ClaudeParseResult: Sendable {
+        let days: [String: [String: [Int]]]
+        let parsedBytes: Int64
+    }
+
+    static func loadDailyReport(
+        provider: UsageProvider,
+        since: Date,
+        until: Date,
+        now: Date = Date(),
+        options: Options = Options()) -> CostUsageDailyReport
+    {
+        let range = CostUsageDayRange(since: since, until: until)
+
+        switch provider {
+        case .codex:
+            return self.loadCodexDaily(range: range, now: now, options: options)
+        case .claude:
+            return self.loadClaudeDaily(range: range, now: now, options: options)
+        case .zai:
+            return CostUsageDailyReport(data: [], summary: nil)
+        case .gemini:
+            return CostUsageDailyReport(data: [], summary: nil)
+        case .antigravity:
+            return CostUsageDailyReport(data: [], summary: nil)
+        case .cursor:
+            return CostUsageDailyReport(data: [], summary: nil)
+        case .factory:
+            return CostUsageDailyReport(data: [], summary: nil)
+        case .copilot:
+            return CostUsageDailyReport(data: [], summary: nil)
+        case .minimax:
+            return CostUsageDailyReport(data: [], summary: nil)
+        case .openrouter:
+            return CostUsageDailyReport(data: [], summary: nil)
+        case .groq:
+            return CostUsageDailyReport(data: [], summary: nil)
+        case .deepseek:
+            return CostUsageDailyReport(data: [], summary: nil)
+        case .fireworks:
+            return CostUsageDailyReport(data: [], summary: nil)
+        case .mistral:
+            return CostUsageDailyReport(data: [], summary: nil)
+        case .perplexity:
+            return CostUsageDailyReport(data: [], summary: nil)
+        case .kimi:
+            return CostUsageDailyReport(data: [], summary: nil)
+        case .auggie:
+            return CostUsageDailyReport(data: [], summary: nil)
+        case .together:
+            return CostUsageDailyReport(data: [], summary: nil)
+        case .cohere:
+            return CostUsageDailyReport(data: [], summary: nil)
+        case .xai:
+            return CostUsageDailyReport(data: [], summary: nil)
+        case .cerebras:
+            return CostUsageDailyReport(data: [], summary: nil)
+        case .sambanova:
+            return CostUsageDailyReport(data: [], summary: nil)
+        case .azure:
+            return CostUsageDailyReport(data: [], summary: nil)
+        case .bedrock:
+            return CostUsageDailyReport(data: [], summary: nil)
+        case .vertexai:
+            return CostUsageDailyReport(data: [], summary: nil)
+        case .qwen:
+            return CostUsageDailyReport(data: [], summary: nil)
+        }
+    }
+
+    // MARK: - Day keys
+
+    struct CostUsageDayRange: Sendable {
+        let sinceKey: String
+        let untilKey: String
+        let scanSinceKey: String
+        let scanUntilKey: String
+
+        init(since: Date, until: Date) {
+            self.sinceKey = Self.dayKey(from: since)
+            self.untilKey = Self.dayKey(from: until)
+            self.scanSinceKey = Self.dayKey(from: Calendar.current.date(byAdding: .day, value: -1, to: since) ?? since)
+            self.scanUntilKey = Self.dayKey(from: Calendar.current.date(byAdding: .day, value: 1, to: until) ?? until)
+        }
+
+        static func dayKey(from date: Date) -> String {
+            let cal = Calendar.current
+            let comps = cal.dateComponents([.year, .month, .day], from: date)
+            let y = comps.year ?? 1970
+            let m = comps.month ?? 1
+            let d = comps.day ?? 1
+            return String(format: "%04d-%02d-%02d", y, m, d)
+        }
+
+        static func isInRange(dayKey: String, since: String, until: String) -> Bool {
+            if dayKey < since { return false }
+            if dayKey > until { return false }
+            return true
+        }
+    }
+
+    // MARK: - Codex
+
+    private static func defaultCodexSessionsRoot(options: Options) -> URL {
+        if let override = options.codexSessionsRoot { return override }
+        let env = ProcessInfo.processInfo.environment["CODEX_HOME"]?.trimmingCharacters(in: .whitespacesAndNewlines)
+        if let env, !env.isEmpty {
+            return URL(fileURLWithPath: env).appendingPathComponent("sessions", isDirectory: true)
+        }
+        return FileManager.default.homeDirectoryForCurrentUser
+            .appendingPathComponent(".codex", isDirectory: true)
+            .appendingPathComponent("sessions", isDirectory: true)
+    }
+
+    private static func listCodexSessionFiles(root: URL, scanSinceKey: String, scanUntilKey: String) -> [URL] {
+        var out: [URL] = []
+        var date = Self.parseDayKey(scanSinceKey) ?? Date()
+        let untilDate = Self.parseDayKey(scanUntilKey) ?? date
+
+        while date <= untilDate {
+            let comps = Calendar.current.dateComponents([.year, .month, .day], from: date)
+            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 dayDir = root.appendingPathComponent(y, isDirectory: true)
+                .appendingPathComponent(m, isDirectory: true)
+                .appendingPathComponent(d, isDirectory: true)
+
+            if let items = try? FileManager.default.contentsOfDirectory(
+                at: dayDir,
+                includingPropertiesForKeys: [.isRegularFileKey],
+                options: [.skipsHiddenFiles])
+            {
+                for item in items where item.pathExtension.lowercased() == "jsonl" {
+                    out.append(item)
+                }
+            }
+
+            date = Calendar.current.date(byAdding: .day, value: 1, to: date) ?? untilDate.addingTimeInterval(1)
+        }
+
+        return out
+    }
+
+    static func parseCodexFile(
+        fileURL: URL,
+        range: CostUsageDayRange,
+        startOffset: Int64 = 0,
+        initialModel: String? = nil,
+        initialTotals: CostUsageCodexTotals? = nil) -> CodexParseResult
+    {
+        var currentModel = initialModel
+        var previousTotals = initialTotals
+
+        var days: [String: [String: [Int]]] = [:]
+
+        func add(dayKey: String, model: String, input: Int, cached: Int, output: Int) {
+            guard CostUsageDayRange.isInRange(dayKey: dayKey, since: range.scanSinceKey, until: range.scanUntilKey)
+            else { return }
+            let normModel = CostUsagePricing.normalizeCodexModel(model)
+
+            var dayModels = days[dayKey] ?? [:]
+            var packed = dayModels[normModel] ?? [0, 0, 0]
+            packed[0] = (packed[safe: 0] ?? 0) + input
+            packed[1] = (packed[safe: 1] ?? 0) + cached
+            packed[2] = (packed[safe: 2] ?? 0) + output
+            dayModels[normModel] = packed
+            days[dayKey] = dayModels
+        }
+
+        let maxLineBytes = 256 * 1024
+        let prefixBytes = 32 * 1024
+
+        let parsedBytes = (try? CostUsageJsonl.scan(
+            fileURL: fileURL,
+            offset: startOffset,
+            maxLineBytes: maxLineBytes,
+            prefixBytes: prefixBytes,
+            onLine: { line in
+                guard !line.bytes.isEmpty else { return }
+                guard !line.wasTruncated else { return }
+
+                guard
+                    line.bytes.containsAscii(#""type":"event_msg""#)
+                    || line.bytes.containsAscii(#""type":"turn_context""#)
+                else { return }
+
+                if line.bytes.containsAscii(#""type":"event_msg""#), !line.bytes.containsAscii(#""token_count""#) {
+                    return
+                }
+
+                guard
+                    let obj = (try? JSONSerialization.jsonObject(with: line.bytes)) as? [String: Any],
+                    let type = obj["type"] as? String
+                else { return }
+
+                guard let tsText = obj["timestamp"] as? String else { return }
+                guard let dayKey = Self.dayKeyFromTimestamp(tsText) ?? Self.dayKeyFromParsedISO(tsText) else { return }
+
+                if type == "turn_context" {
+                    if let payload = obj["payload"] as? [String: Any] {
+                        if let model = payload["model"] as? String {
+                            currentModel = model
+                        } else if let info = payload["info"] as? [String: Any], let model = info["model"] as? String {
+                            currentModel = model
+                        }
+                    }
+                    return
+                }
+
+                guard type == "event_msg" else { return }
+                guard let payload = obj["payload"] as? [String: Any] else { return }
+                guard (payload["type"] as? String) == "token_count" else { return }
+
+                let info = payload["info"] as? [String: Any]
+                let modelFromInfo = info?["model"] as? String
+                    ?? info?["model_name"] as? String
+                    ?? payload["model"] as? String
+                    ?? obj["model"] as? String
+                let model = modelFromInfo ?? currentModel ?? "gpt-5"
+
+                func toInt(_ v: Any?) -> Int {
+                    if let n = v as? NSNumber { return n.intValue }
+                    return 0
+                }
+
+                let total = (info?["total_token_usage"] as? [String: Any])
+                let last = (info?["last_token_usage"] as? [String: Any])
+
+                var deltaInput = 0
+                var deltaCached = 0
+                var deltaOutput = 0
+
+                if let total {
+                    let input = toInt(total["input_tokens"])
+                    let cached = toInt(total["cached_input_tokens"] ?? total["cache_read_input_tokens"])
+                    let output = toInt(total["output_tokens"])
+
+                    let prev = previousTotals
+                    deltaInput = max(0, input - (prev?.input ?? 0))
+                    deltaCached = max(0, cached - (prev?.cached ?? 0))
+                    deltaOutput = max(0, output - (prev?.output ?? 0))
+                    previousTotals = CostUsageCodexTotals(input: input, cached: cached, output: output)
+                } else if let last {
+                    deltaInput = max(0, toInt(last["input_tokens"]))
+                    deltaCached = max(0, toInt(last["cached_input_tokens"] ?? last["cache_read_input_tokens"]))
+                    deltaOutput = max(0, toInt(last["output_tokens"]))
+                } else {
+                    return
+                }
+
+                if deltaInput == 0, deltaCached == 0, deltaOutput == 0 { return }
+                let cachedClamp = min(deltaCached, deltaInput)
+                add(dayKey: dayKey, model: model, input: deltaInput, cached: cachedClamp, output: deltaOutput)
+            })) ?? startOffset
+
+        return CodexParseResult(
+            days: days,
+            parsedBytes: parsedBytes,
+            lastModel: currentModel,
+            lastTotals: previousTotals)
+    }
+
+    private static func loadCodexDaily(range: CostUsageDayRange, now: Date, options: Options) -> CostUsageDailyReport {
+        var cache = CostUsageCacheIO.load(provider: .codex, cacheRoot: options.cacheRoot)
+        let nowMs = Int64(now.timeIntervalSince1970 * 1000)
+
+        let refreshMs = Int64(max(0, options.refreshMinIntervalSeconds) * 1000)
+        let shouldRefresh = refreshMs == 0 || cache.lastScanUnixMs == 0 || nowMs - cache.lastScanUnixMs > refreshMs
+
+        let root = self.defaultCodexSessionsRoot(options: options)
+        let files = Self.listCodexSessionFiles(
+            root: root,
+            scanSinceKey: range.scanSinceKey,
+            scanUntilKey: range.scanUntilKey)
+        let filePathsInScan = Set(files.map(\.path))
+
+        if shouldRefresh {
+            if options.forceRescan {
+                cache = CostUsageCache()
+            }
+            for fileURL in files {
+                let path = fileURL.path
+                let attrs = (try? FileManager.default.attributesOfItem(atPath: path)) ?? [:]
+                let mtime = (attrs[.modificationDate] as? Date)?.timeIntervalSince1970 ?? 0
+                let size = (attrs[.size] as? NSNumber)?.int64Value ?? 0
+                let mtimeMs = Int64(mtime * 1000)
+
+                if let cached = cache.files[path],
+                   cached.mtimeUnixMs == mtimeMs,
+                   cached.size == size
+                {
+                    continue
+                }
+
+                if let cached = cache.files[path] {
+                    let startOffset = cached.parsedBytes ?? cached.size
+                    let canIncremental = size > cached.size && startOffset > 0 && startOffset <= size
+                        && cached.lastTotals != nil
+                    if canIncremental {
+                        let delta = Self.parseCodexFile(
+                            fileURL: fileURL,
+                            range: range,
+                            startOffset: startOffset,
+                            initialModel: cached.lastModel,
+                            initialTotals: cached.lastTotals)
+                        if !delta.days.isEmpty {
+                            Self.applyFileDays(cache: &cache, fileDays: delta.days, sign: 1)
+                        }
+
+                        var mergedDays = cached.days
+                        Self.mergeFileDays(existing: &mergedDays, delta: delta.days)
+                        cache.files[path] = Self.makeFileUsage(
+                            mtimeUnixMs: mtimeMs,
+                            size: size,
+                            days: mergedDays,
+                            parsedBytes: delta.parsedBytes,
+                            lastModel: delta.lastModel,
+                            lastTotals: delta.lastTotals)
+                        continue
+                    }
+
+                    Self.applyFileDays(cache: &cache, fileDays: cached.days, sign: -1)
+                }
+
+                let parsed = Self.parseCodexFile(fileURL: fileURL, range: range)
+                let usage = Self.makeFileUsage(
+                    mtimeUnixMs: mtimeMs,
+                    size: size,
+                    days: parsed.days,
+                    parsedBytes: parsed.parsedBytes,
+                    lastModel: parsed.lastModel,
+                    lastTotals: parsed.lastTotals)
+                cache.files[path] = usage
+                Self.applyFileDays(cache: &cache, fileDays: usage.days, sign: 1)
+            }
+
+            for key in cache.files.keys where !filePathsInScan.contains(key) {
+                if let old = cache.files[key] {
+                    Self.applyFileDays(cache: &cache, fileDays: old.days, sign: -1)
+                }
+                cache.files.removeValue(forKey: key)
+            }
+
+            Self.pruneDays(cache: &cache, sinceKey: range.scanSinceKey, untilKey: range.scanUntilKey)
+            cache.lastScanUnixMs = nowMs
+            CostUsageCacheIO.save(provider: .codex, cache: cache, cacheRoot: options.cacheRoot)
+        }
+
+        return Self.buildCodexReportFromCache(cache: cache, range: range)
+    }
+
+    private static func buildCodexReportFromCache(
+        cache: CostUsageCache,
+        range: CostUsageDayRange) -> CostUsageDailyReport
+    {
+        var entries: [CostUsageDailyReport.Entry] = []
+        var totalInput = 0
+        var totalOutput = 0
+        var totalTokens = 0
+        var totalCost: Double = 0
+        var costSeen = false
+
+        let dayKeys = cache.days.keys.sorted().filter {
+            CostUsageDayRange.isInRange(dayKey: $0, since: range.sinceKey, until: range.untilKey)
+        }
+
+        for day in dayKeys {
+            guard let models = cache.days[day] else { continue }
+            let modelNames = models.keys.sorted()
+
+            var dayInput = 0
+            var dayOutput = 0
+
+            var breakdown: [CostUsageDailyReport.ModelBreakdown] = []
+            var dayCost: Double = 0
+            var dayCostSeen = false
+
+            for model in modelNames {
+                let packed = models[model] ?? [0, 0, 0]
+                let input = packed[safe: 0] ?? 0
+                let cached = packed[safe: 1] ?? 0
+                let output = packed[safe: 2] ?? 0
+
+                dayInput += input
+                dayOutput += output
+
+                let cost = CostUsagePricing.codexCostUSD(
+                    model: model,
+                    inputTokens: input,
+                    cachedInputTokens: cached,
+                    outputTokens: output)
+                breakdown.append(CostUsageDailyReport.ModelBreakdown(modelName: model, costUSD: cost))
+                if let cost {
+                    dayCost += cost
+                    dayCostSeen = true
+                }
+            }
+
+            breakdown.sort { lhs, rhs in (rhs.costUSD ?? -1) < (lhs.costUSD ?? -1) }
+            let top = Array(breakdown.prefix(3))
+
+            let dayTotal = dayInput + dayOutput
+            let entryCost = dayCostSeen ? dayCost : nil
+            entries.append(CostUsageDailyReport.Entry(
+                date: day,
+                inputTokens: dayInput,
+                outputTokens: dayOutput,
+                totalTokens: dayTotal,
+                costUSD: entryCost,
+                modelsUsed: modelNames,
+                modelBreakdowns: top))
+
+            totalInput += dayInput
+            totalOutput += dayOutput
+            totalTokens += dayTotal
+            if let entryCost {
+                totalCost += entryCost
+                costSeen = true
+            }
+        }
+
+        let summary: CostUsageDailyReport.Summary? = entries.isEmpty
+            ? nil
+            : CostUsageDailyReport.Summary(
+                totalInputTokens: totalInput,
+                totalOutputTokens: totalOutput,
+                totalTokens: totalTokens,
+                totalCostUSD: costSeen ? totalCost : nil)
+
+        return CostUsageDailyReport(data: entries, summary: summary)
+    }
+
+    // MARK: - Shared cache mutations
+
+    static func makeFileUsage(
+        mtimeUnixMs: Int64,
+        size: Int64,
+        days: [String: [String: [Int]]],
+        parsedBytes: Int64?,
+        lastModel: String? = nil,
+        lastTotals: CostUsageCodexTotals? = nil) -> CostUsageFileUsage
+    {
+        CostUsageFileUsage(
+            mtimeUnixMs: mtimeUnixMs,
+            size: size,
+            days: days,
+            parsedBytes: parsedBytes,
+            lastModel: lastModel,
+            lastTotals: lastTotals)
+    }
+
+    static func mergeFileDays(
+        existing: inout [String: [String: [Int]]],
+        delta: [String: [String: [Int]]])
+    {
+        for (day, models) in delta {
+            var dayModels = existing[day] ?? [:]
+            for (model, packed) in models {
+                let existingPacked = dayModels[model] ?? []
+                let merged = Self.addPacked(a: existingPacked, b: packed, sign: 1)
+                if merged.allSatisfy({ $0 == 0 }) {
+                    dayModels.removeValue(forKey: model)
+                } else {
+                    dayModels[model] = merged
+                }
+            }
+
+            if dayModels.isEmpty {
+                existing.removeValue(forKey: day)
+            } else {
+                existing[day] = dayModels
+            }
+        }
+    }
+
+    static func applyFileDays(cache: inout CostUsageCache, fileDays: [String: [String: [Int]]], sign: Int) {
+        for (day, models) in fileDays {
+            var dayModels = cache.days[day] ?? [:]
+            for (model, packed) in models {
+                let existing = dayModels[model] ?? []
+                let merged = Self.addPacked(a: existing, b: packed, sign: sign)
+                if merged.allSatisfy({ $0 == 0 }) {
+                    dayModels.removeValue(forKey: model)
+                } else {
+                    dayModels[model] = merged
+                }
+            }
+
+            if dayModels.isEmpty {
+                cache.days.removeValue(forKey: day)
+            } else {
+                cache.days[day] = dayModels
+            }
+        }
+    }
+
+    static func pruneDays(cache: inout CostUsageCache, sinceKey: String, untilKey: String) {
+        for key in cache.days.keys where !CostUsageDayRange.isInRange(dayKey: key, since: sinceKey, until: untilKey) {
+            cache.days.removeValue(forKey: key)
+        }
+    }
+
+    static func addPacked(a: [Int], b: [Int], sign: Int) -> [Int] {
+        let len = max(a.count, b.count)
+        var out: [Int] = Array(repeating: 0, count: len)
+        for idx in 0..<len {
+            let next = (a[safe: idx] ?? 0) + sign * (b[safe: idx] ?? 0)
+            out[idx] = max(0, next)
+        }
+        return out
+    }
+
+    // MARK: - Date parsing
+
+    private static func parseDayKey(_ key: String) -> Date? {
+        let parts = key.split(separator: "-")
+        guard parts.count == 3 else { return nil }
+        guard
+            let y = Int(parts[0]),
+            let m = Int(parts[1]),
+            let d = Int(parts[2])
+        else { return nil }
+
+        var comps = DateComponents()
+        comps.calendar = Calendar.current
+        comps.timeZone = TimeZone.current
+        comps.year = y
+        comps.month = m
+        comps.day = d
+        comps.hour = 12
+        return comps.date
+    }
+}
+
+extension Data {
+    func containsAscii(_ needle: String) -> Bool {
+        guard let n = needle.data(using: .utf8) else { return false }
+        return self.range(of: n) != nil
+    }
+}
+
+extension [Int] {
+    subscript(safe index: Int) -> Int? {
+        if index < 0 { return nil }
+        if index >= self.count { return nil }
+        return self[index]
+    }
+}
+
+extension [UInt8] {
+    subscript(safe index: Int) -> UInt8? {
+        if index < 0 { return nil }
+        if index >= self.count { return nil }
+        return self[index]
+    }
+}