@sriinnu/runic 1.0.0

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

@@ -0,0 +1,455 @@
+import Foundation
+
+extension CostUsageScanner {
+    // MARK: - Claude
+
+    private static func defaultClaudeProjectsRoots(options: Options) -> [URL] {
+        if let override = options.claudeProjectsRoots { return override }
+
+        var roots: [URL] = []
+
+        if let env = ProcessInfo.processInfo.environment["CLAUDE_CONFIG_DIR"]?
+            .trimmingCharacters(in: .whitespacesAndNewlines),
+            !env.isEmpty
+        {
+            for part in env.split(separator: ",") {
+                let raw = String(part).trimmingCharacters(in: .whitespacesAndNewlines)
+                guard !raw.isEmpty else { continue }
+                let url = URL(fileURLWithPath: raw)
+                if url.lastPathComponent == "projects" {
+                    roots.append(url)
+                } else {
+                    roots.append(url.appendingPathComponent("projects", isDirectory: true))
+                }
+            }
+        } else {
+            let home = FileManager.default.homeDirectoryForCurrentUser
+            roots.append(home.appendingPathComponent(".config/claude/projects", isDirectory: true))
+            roots.append(home.appendingPathComponent(".claude/projects", isDirectory: true))
+        }
+
+        return roots
+    }
+
+    static func parseClaudeFile(
+        fileURL: URL,
+        range: CostUsageDayRange,
+        startOffset: Int64 = 0) -> ClaudeParseResult
+    {
+        var days: [String: [String: [Int]]] = [:]
+        // Track seen message+request IDs to deduplicate streaming chunks within a JSONL file.
+        // Claude emits multiple lines per message with cumulative usage, so we only count once.
+        var seenKeys: Set<String> = []
+
+        struct ClaudeTokens: Sendable {
+            let input: Int
+            let cacheRead: Int
+            let cacheCreate: Int
+            let output: Int
+            let costNanos: Int
+        }
+
+        func add(dayKey: String, model: String, tokens: ClaudeTokens) {
+            guard CostUsageDayRange.isInRange(dayKey: dayKey, since: range.scanSinceKey, until: range.scanUntilKey)
+            else { return }
+            let normModel = CostUsagePricing.normalizeClaudeModel(model)
+            var dayModels = days[dayKey] ?? [:]
+            var packed = dayModels[normModel] ?? [0, 0, 0, 0, 0]
+            packed[0] = (packed[safe: 0] ?? 0) + tokens.input
+            packed[1] = (packed[safe: 1] ?? 0) + tokens.cacheRead
+            packed[2] = (packed[safe: 2] ?? 0) + tokens.cacheCreate
+            packed[3] = (packed[safe: 3] ?? 0) + tokens.output
+            packed[4] = (packed[safe: 4] ?? 0) + tokens.costNanos
+            dayModels[normModel] = packed
+            days[dayKey] = dayModels
+        }
+
+        let maxLineBytes = 512 * 1024
+        // Keep the full line so usage at the tail isn't dropped on large tool outputs.
+        let prefixBytes = maxLineBytes
+        let costScale = 1_000_000_000.0
+
+        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":"assistant""#) else { return }
+                guard line.bytes.containsAscii(#""usage""#) else { return }
+
+                guard
+                    let obj = (try? JSONSerialization.jsonObject(with: line.bytes)) as? [String: Any],
+                    let type = obj["type"] as? String,
+                    type == "assistant"
+                else { return }
+
+                guard let tsText = obj["timestamp"] as? String else { return }
+                guard let dayKey = Self.dayKeyFromTimestamp(tsText) ?? Self.dayKeyFromParsedISO(tsText) else { return }
+
+                guard let message = obj["message"] as? [String: Any] else { return }
+                guard let model = message["model"] as? String else { return }
+                guard let usage = message["usage"] as? [String: Any] else { return }
+
+                // Deduplicate by message.id + requestId (streaming chunks have same usage).
+                let messageId = message["id"] as? String
+                let requestId = obj["requestId"] as? String
+                if let messageId, let requestId {
+                    let key = "\(messageId):\(requestId)"
+                    if seenKeys.contains(key) { return }
+                    seenKeys.insert(key)
+                } else {
+                    // Older logs omit IDs; treat each line as distinct to avoid dropping usage.
+                }
+
+                func toInt(_ v: Any?) -> Int {
+                    if let n = v as? NSNumber { return n.intValue }
+                    return 0
+                }
+
+                let input = max(0, toInt(usage["input_tokens"]))
+                let cacheCreate = max(0, toInt(usage["cache_creation_input_tokens"]))
+                let cacheRead = max(0, toInt(usage["cache_read_input_tokens"]))
+                let output = max(0, toInt(usage["output_tokens"]))
+                if input == 0, cacheCreate == 0, cacheRead == 0, output == 0 { return }
+
+                let cost = CostUsagePricing.claudeCostUSD(
+                    model: model,
+                    inputTokens: input,
+                    cacheReadInputTokens: cacheRead,
+                    cacheCreationInputTokens: cacheCreate,
+                    outputTokens: output)
+                let costNanos = cost.map { Int(($0 * costScale).rounded()) } ?? 0
+                let tokens = ClaudeTokens(
+                    input: input,
+                    cacheRead: cacheRead,
+                    cacheCreate: cacheCreate,
+                    output: output,
+                    costNanos: costNanos)
+                add(dayKey: dayKey, model: model, tokens: tokens)
+            })) ?? startOffset
+
+        return ClaudeParseResult(days: days, parsedBytes: parsedBytes)
+    }
+
+    private static func claudeRootCandidates(for rootPath: String) -> [String] {
+        if rootPath.hasPrefix("/var/") {
+            return ["/private" + rootPath, rootPath]
+        }
+        if rootPath.hasPrefix("/private/var/") {
+            let trimmed = String(rootPath.dropFirst("/private".count))
+            return [rootPath, trimmed]
+        }
+        return [rootPath]
+    }
+
+    private final class ClaudeScanState {
+        var cache: CostUsageCache
+        var rootCache: [String: Int64]
+        var touched: Set<String>
+
+        init(cache: CostUsageCache) {
+            self.cache = cache
+            self.rootCache = cache.roots ?? [:]
+            self.touched = []
+        }
+    }
+
+    private static func processClaudeFile(
+        url: URL,
+        size: Int64,
+        mtimeMs: Int64,
+        range: CostUsageDayRange,
+        state: ClaudeScanState)
+    {
+        let path = url.path
+        state.touched.insert(path)
+
+        if let cached = state.cache.files[path],
+           cached.mtimeUnixMs == mtimeMs,
+           cached.size == size
+        {
+            return
+        }
+
+        if let cached = state.cache.files[path] {
+            let startOffset = cached.parsedBytes ?? cached.size
+            let canIncremental = size > cached.size && startOffset > 0 && startOffset <= size
+            if canIncremental {
+                let delta = Self.parseClaudeFile(
+                    fileURL: url,
+                    range: range,
+                    startOffset: startOffset)
+                if !delta.days.isEmpty {
+                    Self.applyFileDays(cache: &state.cache, fileDays: delta.days, sign: 1)
+                }
+
+                var mergedDays = cached.days
+                Self.mergeFileDays(existing: &mergedDays, delta: delta.days)
+                state.cache.files[path] = Self.makeFileUsage(
+                    mtimeUnixMs: mtimeMs,
+                    size: size,
+                    days: mergedDays,
+                    parsedBytes: delta.parsedBytes)
+                return
+            }
+
+            Self.applyFileDays(cache: &state.cache, fileDays: cached.days, sign: -1)
+        }
+
+        let parsed = Self.parseClaudeFile(fileURL: url, range: range)
+        let usage = Self.makeFileUsage(
+            mtimeUnixMs: mtimeMs,
+            size: size,
+            days: parsed.days,
+            parsedBytes: parsed.parsedBytes)
+        state.cache.files[path] = usage
+        Self.applyFileDays(cache: &state.cache, fileDays: usage.days, sign: 1)
+    }
+
+    private static func scanClaudeRoot(
+        root: URL,
+        range: CostUsageDayRange,
+        state: ClaudeScanState)
+    {
+        let rootPath = root.path
+        let rootCandidates = Self.claudeRootCandidates(for: rootPath)
+        let prefixes = Set(rootCandidates).map { path in
+            path.hasSuffix("/") ? path : "\(path)/"
+        }
+        let rootExists = rootCandidates.contains { FileManager.default.fileExists(atPath: $0) }
+        let canonicalRootPath = rootCandidates.first(where: {
+            FileManager.default.fileExists(atPath: $0)
+        }) ?? rootPath
+
+        guard rootExists else {
+            let stale = state.cache.files.keys.filter { path in
+                prefixes.contains(where: { path.hasPrefix($0) })
+            }
+            for path in stale {
+                if let old = state.cache.files[path] {
+                    Self.applyFileDays(cache: &state.cache, fileDays: old.days, sign: -1)
+                }
+                state.cache.files.removeValue(forKey: path)
+            }
+            for candidate in rootCandidates {
+                state.rootCache.removeValue(forKey: candidate)
+            }
+            return
+        }
+
+        let rootAttrs = (try? FileManager.default.attributesOfItem(atPath: canonicalRootPath)) ?? [:]
+        let rootMtime = (rootAttrs[.modificationDate] as? Date)?.timeIntervalSince1970 ?? 0
+        let rootMtimeMs = Int64(rootMtime * 1000)
+        let cachedRootMtime = rootCandidates.compactMap { state.rootCache[$0] }.first
+        let canSkipEnumeration = cachedRootMtime == rootMtimeMs && rootMtimeMs > 0
+
+        if canSkipEnumeration {
+            let cachedPaths = state.cache.files.keys.filter { path in
+                prefixes.contains(where: { path.hasPrefix($0) })
+            }
+            for path in cachedPaths {
+                guard FileManager.default.fileExists(atPath: path) else {
+                    if let old = state.cache.files[path] {
+                        Self.applyFileDays(cache: &state.cache, fileDays: old.days, sign: -1)
+                    }
+                    state.cache.files.removeValue(forKey: path)
+                    continue
+                }
+                let attrs = (try? FileManager.default.attributesOfItem(atPath: path)) ?? [:]
+                let size = (attrs[.size] as? NSNumber)?.int64Value ?? 0
+                if size <= 0 { continue }
+                let mtime = (attrs[.modificationDate] as? Date)?.timeIntervalSince1970 ?? 0
+                let mtimeMs = Int64(mtime * 1000)
+                Self.processClaudeFile(
+                    url: URL(fileURLWithPath: path),
+                    size: size,
+                    mtimeMs: mtimeMs,
+                    range: range,
+                    state: state)
+            }
+            return
+        }
+
+        let keys: [URLResourceKey] = [
+            .isRegularFileKey,
+            .contentModificationDateKey,
+            .fileSizeKey,
+        ]
+
+        guard let enumerator = FileManager.default.enumerator(
+            at: root,
+            includingPropertiesForKeys: keys,
+            options: [.skipsHiddenFiles, .skipsPackageDescendants])
+        else { return }
+
+        for case let url as URL in enumerator {
+            guard url.pathExtension.lowercased() == "jsonl" else { continue }
+            guard let values = try? url.resourceValues(forKeys: Set(keys)) else { continue }
+            guard values.isRegularFile == true else { continue }
+            let size = Int64(values.fileSize ?? 0)
+            if size <= 0 { continue }
+
+            let mtime = values.contentModificationDate?.timeIntervalSince1970 ?? 0
+            let mtimeMs = Int64(mtime * 1000)
+            Self.processClaudeFile(
+                url: url,
+                size: size,
+                mtimeMs: mtimeMs,
+                range: range,
+                state: state)
+        }
+
+        if rootMtimeMs > 0 {
+            state.rootCache[canonicalRootPath] = rootMtimeMs
+            for candidate in rootCandidates where candidate != canonicalRootPath {
+                state.rootCache.removeValue(forKey: candidate)
+            }
+        }
+    }
+
+    static func loadClaudeDaily(range: CostUsageDayRange, now: Date, options: Options) -> CostUsageDailyReport {
+        var cache = CostUsageCacheIO.load(provider: .claude, 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 roots = self.defaultClaudeProjectsRoots(options: options)
+
+        var touched: Set<String> = []
+
+        if shouldRefresh {
+            if options.forceRescan {
+                cache = CostUsageCache()
+            }
+            let scanState = ClaudeScanState(cache: cache)
+
+            for root in roots {
+                Self.scanClaudeRoot(
+                    root: root,
+                    range: range,
+                    state: scanState)
+            }
+
+            cache = scanState.cache
+            touched = scanState.touched
+            cache.roots = scanState.rootCache.isEmpty ? nil : scanState.rootCache
+
+            for key in cache.files.keys where !touched.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: .claude, cache: cache, cacheRoot: options.cacheRoot)
+        }
+
+        return Self.buildClaudeReportFromCache(cache: cache, range: range)
+    }
+
+    private static func buildClaudeReportFromCache(
+        cache: CostUsageCache,
+        range: CostUsageDayRange) -> CostUsageDailyReport
+    {
+        var entries: [CostUsageDailyReport.Entry] = []
+        var totalInput = 0
+        var totalOutput = 0
+        var totalCacheRead = 0
+        var totalCacheCreate = 0
+        var totalTokens = 0
+        var totalCost: Double = 0
+        var costSeen = false
+        let costScale = 1_000_000_000.0
+
+        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 dayCacheRead = 0
+            var dayCacheCreate = 0
+
+            var breakdown: [CostUsageDailyReport.ModelBreakdown] = []
+            var dayCost: Double = 0
+            var dayCostSeen = false
+
+            for model in modelNames {
+                let packed = models[model] ?? [0, 0, 0, 0]
+                let input = packed[safe: 0] ?? 0
+                let cacheRead = packed[safe: 1] ?? 0
+                let cacheCreate = packed[safe: 2] ?? 0
+                let output = packed[safe: 3] ?? 0
+                let cachedCost = packed[safe: 4] ?? 0
+
+                // Cache tokens are tracked separately; totalTokens includes input + cache.
+                dayInput += input
+                dayCacheRead += cacheRead
+                dayCacheCreate += cacheCreate
+                dayOutput += output
+
+                let cost = cachedCost > 0
+                    ? Double(cachedCost) / costScale
+                    : CostUsagePricing.claudeCostUSD(
+                        model: model,
+                        inputTokens: input,
+                        cacheReadInputTokens: cacheRead,
+                        cacheCreationInputTokens: cacheCreate,
+                        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 + dayCacheRead + dayCacheCreate + dayOutput
+            let entryCost = dayCostSeen ? dayCost : nil
+            entries.append(CostUsageDailyReport.Entry(
+                date: day,
+                inputTokens: dayInput,
+                outputTokens: dayOutput,
+                cacheReadTokens: dayCacheRead,
+                cacheCreationTokens: dayCacheCreate,
+                totalTokens: dayTotal,
+                costUSD: entryCost,
+                modelsUsed: modelNames,
+                modelBreakdowns: top))
+
+            totalInput += dayInput
+            totalOutput += dayOutput
+            totalCacheRead += dayCacheRead
+            totalCacheCreate += dayCacheCreate
+            totalTokens += dayTotal
+            if let entryCost {
+                totalCost += entryCost
+                costSeen = true
+            }
+        }
+
+        let summary: CostUsageDailyReport.Summary? = entries.isEmpty
+            ? nil
+            : CostUsageDailyReport.Summary(
+                totalInputTokens: totalInput,
+                totalOutputTokens: totalOutput,
+                cacheReadTokens: totalCacheRead,
+                cacheCreationTokens: totalCacheCreate,
+                totalTokens: totalTokens,
+                totalCostUSD: costSeen ? totalCost : nil)
+
+        return CostUsageDailyReport(data: entries, summary: summary)
+    }
+}

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

@@ -0,0 +1,132 @@
+import Foundation
+
+private final class CostUsageISO8601FormatterBox: @unchecked Sendable {
+    let lock = NSLock()
+    let withFractional: ISO8601DateFormatter = {
+        let fmt = ISO8601DateFormatter()
+        fmt.formatOptions = [.withInternetDateTime, .withFractionalSeconds]
+        return fmt
+    }()
+
+    let plain: ISO8601DateFormatter = {
+        let fmt = ISO8601DateFormatter()
+        fmt.formatOptions = [.withInternetDateTime]
+        return fmt
+    }()
+}
+
+private enum CostUsageTimestampParser {
+    static let box = CostUsageISO8601FormatterBox()
+
+    static func parseISO(_ text: String) -> Date? {
+        self.box.lock.lock()
+        defer { self.box.lock.unlock() }
+        return self.box.withFractional.date(from: text) ?? self.box.plain.date(from: text)
+    }
+}
+
+extension CostUsageScanner {
+    static func dayKeyFromTimestamp(_ text: String) -> String? {
+        let bytes = Array(text.utf8)
+        guard bytes.count >= 20 else { return nil }
+        guard bytes[safe: 4] == 45, bytes[safe: 7] == 45 else { return nil }
+        guard let year = Self.parse4(bytes, at: 0),
+              let month = Self.parse2(bytes, at: 5),
+              let day = Self.parse2(bytes, at: 8) else { return nil }
+
+        var hour = 0
+        var minute = 0
+        var second = 0
+
+        if bytes[safe: 10] == 84 {
+            guard bytes.count >= 19 else { return nil }
+            guard bytes[safe: 13] == 58, bytes[safe: 16] == 58 else { return nil }
+            guard let parsedHour = Self.parse2(bytes, at: 11),
+                  let parsedMinute = Self.parse2(bytes, at: 14),
+                  let parsedSecond = Self.parse2(bytes, at: 17) else { return nil }
+            hour = parsedHour
+            minute = parsedMinute
+            second = parsedSecond
+        }
+
+        var tzIndex: Int?
+        var tzSign = 0
+        for idx in stride(from: bytes.count - 1, through: 11, by: -1) {
+            let byte = bytes[idx]
+            if byte == 90 {
+                tzIndex = idx
+                tzSign = 0
+                break
+            }
+            if byte == 43 {
+                tzIndex = idx
+                tzSign = 1
+                break
+            }
+            if byte == 45 {
+                tzIndex = idx
+                tzSign = -1
+                break
+            }
+        }
+
+        guard let tzStart = tzIndex else { return nil }
+        var offsetSeconds = 0
+        if tzSign != 0 {
+            let offsetStart = tzStart + 1
+            guard let hours = Self.parse2(bytes, at: offsetStart) else { return nil }
+            var minutes = 0
+            if bytes.count > offsetStart + 2 {
+                if bytes[safe: offsetStart + 2] == 58 {
+                    guard let parsedMinutes = Self.parse2(bytes, at: offsetStart + 3) else { return nil }
+                    minutes = parsedMinutes
+                } else if let parsedMinutes = Self.parse2(bytes, at: offsetStart + 2) {
+                    minutes = parsedMinutes
+                }
+            }
+            offsetSeconds = tzSign * ((hours * 3600) + (minutes * 60))
+        }
+
+        var comps = DateComponents()
+        comps.calendar = Calendar(identifier: .gregorian)
+        comps.timeZone = TimeZone(secondsFromGMT: offsetSeconds)
+        comps.year = year
+        comps.month = month
+        comps.day = day
+        comps.hour = hour
+        comps.minute = minute
+        comps.second = second
+
+        guard let date = comps.date else { return nil }
+        let local = Calendar.current.dateComponents([.year, .month, .day], from: date)
+        guard let localYear = local.year,
+              let localMonth = local.month,
+              let localDay = local.day else { return nil }
+        return String(format: "%04d-%02d-%02d", localYear, localMonth, localDay)
+    }
+
+    static func dayKeyFromParsedISO(_ text: String) -> String? {
+        guard let date = CostUsageTimestampParser.parseISO(text) else { return nil }
+        return CostUsageDayRange.dayKey(from: date)
+    }
+
+    private static func parse2(_ bytes: [UInt8], at index: Int) -> Int? {
+        guard let d0 = parseDigit(bytes[safe: index]),
+              let d1 = parseDigit(bytes[safe: index + 1]) else { return nil }
+        return d0 * 10 + d1
+    }
+
+    private static func parse4(_ bytes: [UInt8], at index: Int) -> Int? {
+        guard let d0 = parseDigit(bytes[safe: index]),
+              let d1 = parseDigit(bytes[safe: index + 1]),
+              let d2 = parseDigit(bytes[safe: index + 2]),
+              let d3 = parseDigit(bytes[safe: index + 3]) else { return nil }
+        return d0 * 1000 + d1 * 100 + d2 * 10 + d3
+    }
+
+    private static func parseDigit(_ byte: UInt8?) -> Int? {
+        guard let byte else { return nil }
+        guard byte >= 48, byte <= 57 else { return nil }
+        return Int(byte - 48)
+    }
+}