@sriinnu/runic 1.0.0

package/Sources/RunicCLI/Commands/ResetCommand.swift

@@ -0,0 +1,429 @@
+/// ResetCommand.swift
+/// Runic CLI - Usage Reset Timing Information
+///
+/// Displays when usage limits reset for different providers,
+/// helping you plan usage and understand billing cycles.
+///
+/// Usage:
+///   runic reset [--when <provider>] [--all] [--json] [--pretty] [--no-color]
+///
+/// Examples:
+///   runic reset                            # Show reset times for all providers
+///   runic reset --when claude              # Show Claude reset timings only
+///   runic reset --all --json               # JSON output for all providers
+
+import RunicCore
+import Helix
+import Foundation
+
+/// Main entry point for the reset command
+public enum ResetCommand {
+
+    /// Command signature defining available options and flags
+    public static var signature: CommandSignature {
+        CommandSignature(
+            options: [
+                OptionDefinition(
+                    label: "when",
+                    names: [.long("when"), .short("w")],
+                    help: "Show reset timing for specific provider"),
+                OptionDefinition(
+                    label: "format",
+                    names: [.long("format")],
+                    help: "Output format: text | json"),
+            ],
+            flags: [
+                FlagDefinition(
+                    label: "all",
+                    names: [.long("all"), .short("a")],
+                    help: "Show all providers (default)"),
+                FlagDefinition(
+                    label: "json",
+                    names: [.long("json"), .short("j")],
+                    help: "Output in JSON format"),
+                FlagDefinition(
+                    label: "pretty",
+                    names: [.long("pretty")],
+                    help: "Pretty-print JSON output"),
+                FlagDefinition(
+                    label: "noColor",
+                    names: [.long("no-color")],
+                    help: "Disable ANSI color codes"),
+                FlagDefinition(
+                    label: "compact",
+                    names: [.long("compact"), .short("c")],
+                    help: "Show compact output"),
+            ])
+    }
+
+    /// Command descriptor for registration
+    public static var descriptor: CommandDescriptor {
+        CommandDescriptor(
+            name: "reset",
+            abstract: "Show when usage limits reset",
+            discussion: """
+            Displays reset timing information for provider usage limits.
+            Shows when current usage windows expire and new limits begin.
+
+            Supports all Runic providers including Claude, Codex, Gemini,
+            Cursor, and others with usage-based billing.
+
+            EXAMPLES:
+              runic reset
+                Show reset times for all active providers
+
+              runic reset --when claude
+                Show Claude-specific reset information
+
+              runic reset --all --json
+                Export all reset timings as JSON
+
+              runic reset --compact
+                Show compact, single-line output per provider
+            """,
+            signature: signature)
+    }
+
+    /// Execute the reset command
+    public static func run(_ invocation: CommandInvocation) async {
+        let config = parseConfiguration(invocation)
+
+        do {
+            let resetInfos = try await loadResetInformation(providers: config.providers)
+
+            if resetInfos.isEmpty {
+                exitWithError("No reset information available for the specified providers.")
+            }
+
+            if config.isJSON {
+                outputJSON(resetInfos, pretty: config.isPretty)
+            } else {
+                outputText(resetInfos, config: config)
+            }
+        } catch {
+            exitWithError("Failed to load reset information: \(error.localizedDescription)")
+        }
+    }
+
+    // MARK: - Configuration
+
+    private struct Configuration {
+        let providers: [UsageProvider]
+        let isJSON: Bool
+        let isPretty: Bool
+        let useColor: Bool
+        let compact: Bool
+    }
+
+    private static func parseConfiguration(_ invocation: CommandInvocation) -> Configuration {
+        let whenArg = invocation.parsedValues.options["when"]?.first
+        let formatArg = invocation.parsedValues.options["format"]?.first ?? "text"
+
+        let isJSON = invocation.parsedValues.flags.contains("json")
+            || formatArg.lowercased() == "json"
+        let isPretty = invocation.parsedValues.flags.contains("pretty")
+        let noColor = invocation.parsedValues.flags.contains("noColor")
+        let compact = invocation.parsedValues.flags.contains("compact")
+
+        let providers = resolveProviders(whenArg)
+
+        return Configuration(
+            providers: providers,
+            isJSON: isJSON,
+            isPretty: isPretty,
+            useColor: !noColor,
+            compact: compact)
+    }
+
+    private static func resolveProviders(_ arg: String?) -> [UsageProvider] {
+        guard let arg = arg?.lowercased().trimmingCharacters(in: .whitespaces) else {
+            return ProviderDescriptorRegistry.all.map(\.id)
+        }
+
+        if arg == "all" {
+            return ProviderDescriptorRegistry.all.map(\.id)
+        }
+
+        guard let provider = UsageProvider(rawValue: arg) else {
+            exitWithError("Unknown provider: \(arg)")
+        }
+
+        return [provider]
+    }
+
+    // MARK: - Reset Information Models
+
+    private struct ProviderResetInfo: Encodable {
+        let provider: UsageProvider
+        let providerName: String
+        let windows: [WindowResetInfo]
+        let status: String
+    }
+
+    private struct WindowResetInfo: Encodable {
+        let windowName: String
+        let resetDescription: String?
+        let resetAt: Date?
+        let timeUntilReset: TimeInterval?
+        let usedPercent: Double
+        let remainingPercent: Double
+        let isNearLimit: Bool
+    }
+
+    // MARK: - Data Loading
+
+    private static func loadResetInformation(
+        providers: [UsageProvider]
+    ) async throws -> [ProviderResetInfo] {
+        let fetcher = UsageFetcher()
+        var results: [ProviderResetInfo] = []
+
+        for provider in providers {
+            let descriptor = ProviderDescriptorRegistry.descriptor(for: provider)
+            let context = ProviderFetchContext(
+                runtime: .cli,
+                sourceMode: .cli,
+                includeCredits: false,
+                webTimeout: 60,
+                webDebugDumpHTML: false,
+                verbose: false,
+                env: ProcessInfo.processInfo.environment,
+                settings: nil,
+                fetcher: fetcher,
+                claudeFetcher: ClaudeUsageFetcher())
+
+            let outcome = await descriptor.fetchOutcome(context: context)
+
+            if case .success(let result) = outcome.result {
+                let info = buildResetInfo(
+                    provider: provider,
+                    snapshot: result.usage,
+                    metadata: descriptor.metadata)
+                results.append(info)
+            }
+        }
+
+        return results
+    }
+
+    private static func buildResetInfo(
+        provider: UsageProvider,
+        snapshot: UsageSnapshot,
+        metadata: ProviderMetadata
+    ) -> ProviderResetInfo {
+        var windows: [WindowResetInfo] = []
+
+        // Primary window
+        windows.append(buildWindowInfo(
+            windowName: metadata.sessionLabel,
+            window: snapshot.primary))
+
+        // Secondary window
+        if let secondary = snapshot.secondary {
+            windows.append(buildWindowInfo(
+                windowName: metadata.weeklyLabel,
+                window: secondary))
+        }
+
+        // Tertiary window (Opus)
+        if metadata.supportsOpus, let tertiary = snapshot.tertiary {
+            windows.append(buildWindowInfo(
+                windowName: metadata.opusLabel ?? "Opus",
+                window: tertiary))
+        }
+
+        let status = determineStatus(windows: windows)
+
+        return ProviderResetInfo(
+            provider: provider,
+            providerName: provider.rawValue.capitalized,
+            windows: windows,
+            status: status)
+    }
+
+    private static func buildWindowInfo(
+        windowName: String,
+        window: RateWindow
+    ) -> WindowResetInfo {
+        let resetAt = extractResetDate(from: window.resetDescription)
+        let timeUntilReset = resetAt?.timeIntervalSinceNow
+
+        return WindowResetInfo(
+            windowName: windowName,
+            resetDescription: window.resetDescription,
+            resetAt: resetAt,
+            timeUntilReset: timeUntilReset,
+            usedPercent: window.usedPercent,
+            remainingPercent: window.remainingPercent,
+            isNearLimit: window.usedPercent >= 75)
+    }
+
+    private static func extractResetDate(from description: String?) -> Date? {
+        // This is a simplified implementation
+        // Real implementation would parse the reset description
+        guard let description = description else { return nil }
+
+        // Look for patterns like "in Xh Ym"
+        let pattern = #"in (\d+)h(?: (\d+)m)?"#
+        guard let regex = try? NSRegularExpression(pattern: pattern),
+              let match = regex.firstMatch(
+                  in: description,
+                  range: NSRange(description.startIndex..., in: description)) else {
+            return nil
+        }
+
+        var hours = 0
+        var minutes = 0
+
+        if let hoursRange = Range(match.range(at: 1), in: description) {
+            hours = Int(description[hoursRange]) ?? 0
+        }
+
+        if match.numberOfRanges > 2, let minutesRange = Range(match.range(at: 2), in: description) {
+            minutes = Int(description[minutesRange]) ?? 0
+        }
+
+        let seconds = TimeInterval(hours * 3600 + minutes * 60)
+        return Date().addingTimeInterval(seconds)
+    }
+
+    private static func determineStatus(windows: [WindowResetInfo]) -> String {
+        let maxUsed = windows.map(\.usedPercent).max() ?? 0
+
+        switch maxUsed {
+        case 90...:
+            return "Critical - Near limit"
+        case 75...:
+            return "Warning - High usage"
+        case 50...:
+            return "Moderate usage"
+        default:
+            return "Healthy"
+        }
+    }
+
+    // MARK: - Output Formatting
+
+    private static func outputJSON(_ infos: [ProviderResetInfo], pretty: Bool) {
+        let encoder = JSONEncoder()
+        encoder.dateEncodingStrategy = .iso8601
+
+        if pretty {
+            encoder.outputFormatting = [.prettyPrinted, .sortedKeys]
+        }
+
+        guard let data = try? encoder.encode(infos),
+              let text = String(data: data, encoding: .utf8) else {
+            print("[]")
+            return
+        }
+
+        print(text)
+    }
+
+    private static func outputText(_ infos: [ProviderResetInfo], config: Configuration) {
+        if config.compact {
+            outputCompactText(infos, useColor: config.useColor)
+        } else {
+            outputDetailedText(infos, useColor: config.useColor)
+        }
+    }
+
+    private static func outputCompactText(_ infos: [ProviderResetInfo], useColor: Bool) {
+        printHeader("Usage Reset Times", useColor: useColor)
+        print("")
+
+        for info in infos {
+            let status = statusIndicator(info.status, useColor: useColor)
+            let provider = info.providerName.padding(toLength: 12, withPad: " ", startingAt: 0)
+
+            var resetTimes: [String] = []
+            for window in info.windows {
+                if let description = window.resetDescription {
+                    resetTimes.append(description)
+                }
+            }
+
+            let resets = resetTimes.joined(separator: ", ")
+            print("\(status) \(provider) \(resets)")
+        }
+    }
+
+    private static func outputDetailedText(_ infos: [ProviderResetInfo], useColor: Bool) {
+        printHeader("Usage Reset Information", useColor: useColor)
+        print("")
+
+        for (index, info) in infos.enumerated() {
+            if index > 0 {
+                print("")
+            }
+
+            let status = statusIndicator(info.status, useColor: useColor)
+            let providerLine = "\(status) \(info.providerName) - \(info.status)"
+
+            if useColor {
+                print(ansi("1;37", providerLine))
+            } else {
+                print(providerLine)
+            }
+
+            for window in info.windows {
+                print("")
+                print("  \(window.windowName):")
+
+                if let description = window.resetDescription {
+                    print("    Reset: \(description)")
+                }
+
+                let used = String(format: "%.1f", window.usedPercent)
+                let remaining = String(format: "%.1f", window.remainingPercent)
+                print("    Usage: \(used)% used, \(remaining)% remaining")
+
+                if window.isNearLimit {
+                    let warning = "⚠ High usage - consider monitoring closely"
+                    if useColor {
+                        print("    \(ansi("33", warning))")
+                    } else {
+                        print("    \(warning)")
+                    }
+                }
+            }
+        }
+    }
+
+    private static func statusIndicator(_ status: String, useColor: Bool) -> String {
+        let (icon, color) = switch status {
+        case let s where s.contains("Critical"):
+            ("✗", "31")
+        case let s where s.contains("Warning"):
+            ("⚠", "33")
+        case let s where s.contains("Moderate"):
+            ("◐", "36")
+        default:
+            ("✓", "32")
+        }
+
+        return useColor ? ansi(color, icon) : icon
+    }
+
+    private static func printHeader(_ text: String, useColor: Bool) {
+        if useColor {
+            print(ansi("1;36", text))
+        } else {
+            print(text)
+        }
+    }
+
+    private static func ansi(_ code: String, _ text: String) -> String {
+        "\u{001B}[\(code)m\(text)\u{001B}[0m"
+    }
+
+    // MARK: - Error Handling
+
+    private static func exitWithError(_ message: String) -> Never {
+        if let data = ("Error: " + message + "\n").data(using: .utf8) {
+            FileHandle.standardError.write(data)
+        }
+        Foundation.exit(1)
+    }
+}

package/Sources/RunicCLI/Commands/UsageLedgerSourceFactory.swift

@@ -0,0 +1,168 @@
+import Foundation
+import RunicCore
+
+enum UsageLedgerSourceFactory {
+    static func source(
+        for provider: UsageProvider,
+        now: Date,
+        maxAgeDays: Int
+    ) -> (any UsageLedgerSource)? {
+        switch provider {
+        case .claude:
+            return ClaudeUsageLogSource(maxAgeDays: maxAgeDays, now: now)
+        case .codex:
+            return CodexUsageLogSource(maxAgeDays: maxAgeDays, now: now)
+        case .copilot,
+            .gemini,
+            .antigravity,
+            .cursor,
+            .factory,
+            .zai,
+            .minimax,
+            .openrouter,
+            .groq,
+            .deepseek,
+            .fireworks,
+            .mistral,
+            .perplexity,
+            .kimi,
+            .auggie,
+            .together,
+            .cohere,
+            .xai,
+            .cerebras,
+            .sambanova,
+            .azure,
+            .bedrock,
+            .vertexai,
+            .qwen:
+            return Self.otelHistorySource(provider: provider, now: now, maxAgeDays: maxAgeDays)
+        @unknown default:
+            return nil
+        }
+    }
+
+    private static func otelHistorySource(
+        provider: UsageProvider,
+        now: Date,
+        maxAgeDays: Int
+    ) -> (any UsageLedgerSource)? {
+        let files = self.otelLedgerFiles(for: provider)
+        guard !files.isEmpty else { return nil }
+
+        let cutoff = Calendar.current.date(byAdding: .day, value: -max(1, maxAgeDays), to: now)
+        let options = OTelGenAIIngestionOptions(
+            enabled: true,
+            allowExperimentalSemanticConventions: true,
+            defaultProvider: provider,
+            source: .api)
+        return UsageLedgerProviderFilterSource(
+            source: OTelGenAIFileLedgerSource(files: files, options: options),
+            provider: provider,
+            minTimestamp: cutoff)
+    }
+
+    private static func otelLedgerFiles(for provider: UsageProvider) -> [URL] {
+        let env = ProcessInfo.processInfo.environment
+        let providerKey = provider.rawValue
+            .replacingOccurrences(of: "-", with: "_")
+            .uppercased()
+
+        let candidatePaths = [
+            Self.splitPathList(env["RUNIC_OTEL_GENAI_LOG_PATHS"]),
+            Self.splitPathList(env["RUNIC_OTEL_GENAI_LOG_PATH"]),
+            Self.splitPathList(env["RUNIC_\(providerKey)_OTEL_GENAI_LOG_PATHS"]),
+            Self.splitPathList(env["RUNIC_\(providerKey)_OTEL_GENAI_LOG_PATH"]),
+            Self.splitPathList(env["RUNIC_\(providerKey)_OTEL_LOG_PATHS"]),
+            Self.splitPathList(env["RUNIC_\(providerKey)_OTEL_LOG_PATH"]),
+        ].flatMap { $0 }
+
+        let urls = candidatePaths.compactMap(Self.expandTildePath)
+        return Self.discoverOTelLedgerFiles(from: urls)
+    }
+
+    private static func splitPathList(_ raw: String?) -> [String] {
+        guard let raw else { return [] }
+        return raw
+            .split(whereSeparator: { $0 == "," || $0 == ";" || $0 == "\n" })
+            .map { $0.trimmingCharacters(in: .whitespacesAndNewlines) }
+            .filter { !$0.isEmpty }
+    }
+
+    private static func expandTildePath(_ rawPath: String) -> URL? {
+        let fileManager = FileManager.default
+        if rawPath.hasPrefix("~/") {
+            return fileManager.homeDirectoryForCurrentUser
+                .appendingPathComponent(String(rawPath.dropFirst(2)), isDirectory: true)
+        }
+        return URL(fileURLWithPath: rawPath, isDirectory: true)
+    }
+
+    private static func discoverOTelLedgerFiles(from paths: [URL]) -> [URL] {
+        var found: [URL] = []
+        var seen: Set<String> = []
+
+        for path in paths {
+            if Self.isSupportedOTelFile(path) {
+                if seen.insert(path.standardizedFileURL.path).inserted {
+                    found.append(path.standardizedFileURL)
+                }
+                continue
+            }
+
+            for file in Self.scanOTelDirectory(path) where seen.insert(file.standardizedFileURL.path).inserted {
+                found.append(file.standardizedFileURL)
+            }
+        }
+
+        return found
+    }
+
+    private static func isSupportedOTelFile(_ url: URL) -> Bool {
+        var isDirectory: ObjCBool = false
+        let exists = FileManager.default.fileExists(atPath: url.path, isDirectory: &isDirectory)
+        guard exists && !isDirectory.boolValue else { return false }
+
+        let ext = url.pathExtension.lowercased()
+        return ext == "json" || ext == "jsonl"
+    }
+
+    private static func scanOTelDirectory(_ directory: URL) -> [URL] {
+        var isDirectory: ObjCBool = false
+        guard FileManager.default.fileExists(atPath: directory.path, isDirectory: &isDirectory), isDirectory.boolValue
+        else { return [] }
+
+        guard let enumerator = FileManager.default.enumerator(
+            at: directory,
+            includingPropertiesForKeys: [.isRegularFileKey, .isDirectoryKey],
+            options: [.skipsHiddenFiles]
+        ) else { return [] }
+
+        var files: [URL] = []
+        for case let file as URL in enumerator where Self.isSupportedOTelFile(file) {
+            files.append(file)
+        }
+        return files
+    }
+
+    private struct UsageLedgerProviderFilterSource: UsageLedgerSource, Sendable {
+        private let source: any UsageLedgerSource
+        private let provider: UsageProvider
+        private let minTimestamp: Date?
+
+        init(source: any UsageLedgerSource, provider: UsageProvider, minTimestamp: Date?) {
+            self.source = source
+            self.provider = provider
+            self.minTimestamp = minTimestamp
+        }
+
+        func loadEntries() async throws -> [UsageLedgerEntry] {
+            let entries = try await self.source.loadEntries()
+            return entries.filter { entry in
+                if entry.provider != self.provider { return false }
+                if let minTimestamp, entry.timestamp < minTimestamp { return false }
+                return true
+            }
+        }
+    }
+}