@sriinnu/runic 1.0.0

package/Tests/RunicTests/TeamShowbackExporterTests.swift

@@ -0,0 +1,159 @@
+import Foundation
+import Testing
+
+@testable import RunicCore
+
+@Suite
+struct TeamShowbackExporterTests {
+    @Test
+    func buildsShowbackReportForTeamOwnedProjects() throws {
+        let period = DateInterval(
+            start: self.date(year: 2026, month: 2, day: 1),
+            end: self.date(year: 2026, month: 3, day: 1))
+        let team = Team(
+            id: "team-1",
+            name: "Runic Team",
+            ownerUserID: "u-owner",
+            totalQuota: 500_000,
+            members: [
+                TeamMembership(userID: "u-owner", teamID: "team-1", role: .owner),
+                TeamMembership(userID: "u-member", teamID: "team-1", role: .member),
+            ])
+        let ownerships = [
+            ProjectOwnership(projectID: "proj-a", teamID: "team-1", ownerUserID: "u-owner"),
+            ProjectOwnership(projectID: "proj-b", teamID: "team-1", ownerUserID: "u-member"),
+            ProjectOwnership(projectID: "proj-outside", teamID: "team-2", ownerUserID: "u-owner"),
+        ]
+        let entries = [
+            self.entry(
+                provider: .claude,
+                timestamp: self.date(year: 2026, month: 2, day: 10),
+                projectID: "proj-a",
+                inputTokens: 100,
+                outputTokens: 50,
+                costUSD: 0.30),
+            self.entry(
+                provider: .codex,
+                timestamp: self.date(year: 2026, month: 2, day: 11),
+                projectID: "proj-b",
+                inputTokens: 140,
+                outputTokens: 60,
+                costUSD: 0.45),
+            // Excluded: non-team project
+            self.entry(
+                provider: .codex,
+                timestamp: self.date(year: 2026, month: 2, day: 12),
+                projectID: "proj-outside",
+                inputTokens: 999,
+                outputTokens: 0,
+                costUSD: 9.99),
+            // Excluded: outside period
+            self.entry(
+                provider: .claude,
+                timestamp: self.date(year: 2026, month: 3, day: 3),
+                projectID: "proj-a",
+                inputTokens: 77,
+                outputTokens: 22,
+                costUSD: 0.10),
+        ]
+
+        let report = TeamShowbackExporter.buildReport(
+            team: team,
+            projectOwnerships: ownerships,
+            entries: entries,
+            period: period,
+            generatedAt: self.date(year: 2026, month: 2, day: 28))
+
+        #expect(report.teamID == "team-1")
+        #expect(report.totals.totalTokens == 350)
+        #expect(report.totals.totalRequests == 2)
+        #expect(abs(report.totals.totalCostUSD - 0.75) < 0.000_001)
+        #expect(report.members.count == 2)
+        #expect(report.projects.count == 2)
+        #expect(report.providers.count == 2)
+
+        let owner = try #require(report.members.first { $0.userID == "u-owner" })
+        #expect(owner.role == .owner)
+        #expect(owner.tokens == 150)
+        let member = try #require(report.members.first { $0.userID == "u-member" })
+        #expect(member.role == .member)
+        #expect(member.tokens == 200)
+    }
+
+    @Test
+    func exportsJsonAndCsvFromReport() throws {
+        let period = DateInterval(
+            start: self.date(year: 2026, month: 2, day: 1),
+            end: self.date(year: 2026, month: 3, day: 1))
+        let team = Team(
+            id: "team-export",
+            name: "Exports",
+            ownerUserID: "owner",
+            totalQuota: 100_000,
+            members: [TeamMembership(userID: "owner", teamID: "team-export", role: .owner)])
+        let ownerships = [ProjectOwnership(projectID: "proj-csv", teamID: "team-export", ownerUserID: "owner")]
+        let entries = [
+            self.entry(
+                provider: .codex,
+                timestamp: self.date(year: 2026, month: 2, day: 8),
+                projectID: "proj-csv",
+                inputTokens: 42,
+                outputTokens: 8,
+                costUSD: 0.09),
+        ]
+
+        let bundle = try TeamShowbackExporter.makeExportBundle(
+            team: team,
+            projectOwnerships: ownerships,
+            entries: entries,
+            period: period,
+            generatedAt: self.date(year: 2026, month: 2, day: 28),
+            prettyJSON: false)
+
+        #expect(bundle.json.contains("\"teamID\":\"team-export\""))
+        #expect(bundle.json.contains("\"totalTokens\":50"))
+        #expect(bundle.csv.contains("section,id,name,provider,role,tokens,cost_usd,requests"))
+        #expect(bundle.csv.contains("summary,team-export,Exports"))
+        #expect(bundle.csv.contains("member,owner,owner"))
+        #expect(bundle.csv.contains("provider,codex,codex,codex"))
+    }
+
+    private func entry(
+        provider: UsageProvider,
+        timestamp: Date,
+        projectID: String,
+        inputTokens: Int,
+        outputTokens: Int,
+        costUSD: Double?) -> UsageLedgerEntry
+    {
+        UsageLedgerEntry(
+            provider: provider,
+            timestamp: timestamp,
+            sessionID: "session-\(projectID)",
+            projectID: projectID,
+            projectName: nil,
+            model: "model-\(provider.rawValue)",
+            inputTokens: inputTokens,
+            outputTokens: outputTokens,
+            cacheCreationTokens: 0,
+            cacheReadTokens: 0,
+            costUSD: costUSD,
+            requestID: UUID().uuidString,
+            messageID: nil,
+            version: nil,
+            source: .api)
+    }
+
+    private func date(year: Int, month: Int, day: Int, hour: Int = 12) -> Date {
+        let tz = TimeZone(secondsFromGMT: 0)!
+        var calendar = Calendar(identifier: .gregorian)
+        calendar.timeZone = tz
+        return calendar.date(from: DateComponents(
+            calendar: calendar,
+            timeZone: tz,
+            year: year,
+            month: month,
+            day: day,
+            hour: hour))!
+    }
+}

package/Tests/RunicTests/TextParsingTests.swift

@@ -0,0 +1,12 @@
+import RunicCore
+import Testing
+
+@Suite
+struct TextParsingTests {
+    @Test
+    func stripANSICodesRemovesCursorVisibilityCSI() {
+        let input = "\u{001B}[?25hhello\u{001B}[0m"
+        let stripped = TextParsing.stripANSICodes(input)
+        #expect(stripped == "hello")
+    }
+}

package/Tests/RunicTests/UsageFormatterTests.swift

@@ -0,0 +1,112 @@
+import RunicCore
+import Foundation
+import Testing
+@testable import Runic
+
+@Suite
+struct UsageFormatterTests {
+    @Test
+    func formatsUsageLine() {
+        let line = UsageFormatter.usageLine(remaining: 25, used: 75)
+        #expect(line == "25% left")
+    }
+
+    @Test
+    func relativeUpdatedRecent() {
+        let now = Date()
+        let fiveHoursAgo = now.addingTimeInterval(-5 * 3600)
+        let text = UsageFormatter.updatedString(from: fiveHoursAgo, now: now)
+        #expect(text.contains("Updated"))
+        // Check for relative time format (varies by locale: "ago" in English, "전" in Korean, etc.)
+        #expect(text.contains("5") || text.lowercased().contains("hour") || text.contains("시간"))
+    }
+
+    @Test
+    func absoluteUpdatedOld() {
+        let now = Date()
+        let dayAgo = now.addingTimeInterval(-26 * 3600)
+        let text = UsageFormatter.updatedString(from: dayAgo, now: now)
+        #expect(text.contains("Updated"))
+        #expect(!text.contains("ago"))
+    }
+
+    @Test
+    func resetCountdown_minutes() {
+        let now = Date(timeIntervalSince1970: 1_000_000)
+        let reset = now.addingTimeInterval(10 * 60 + 1)
+        #expect(UsageFormatter.resetCountdownDescription(from: reset, now: now) == "in 11m")
+    }
+
+    @Test
+    func resetCountdown_hoursAndMinutes() {
+        let now = Date(timeIntervalSince1970: 1_000_000)
+        let reset = now.addingTimeInterval(3 * 3600 + 31 * 60)
+        #expect(UsageFormatter.resetCountdownDescription(from: reset, now: now) == "in 3h 31m")
+    }
+
+    @Test
+    func resetCountdown_daysAndHours() {
+        let now = Date(timeIntervalSince1970: 1_000_000)
+        let reset = now.addingTimeInterval((26 * 3600) + 10)
+        #expect(UsageFormatter.resetCountdownDescription(from: reset, now: now) == "in 1d 2h")
+    }
+
+    @Test
+    func resetCountdown_exactHour() {
+        let now = Date(timeIntervalSince1970: 1_000_000)
+        let reset = now.addingTimeInterval(60 * 60)
+        #expect(UsageFormatter.resetCountdownDescription(from: reset, now: now) == "in 1h")
+    }
+
+    @Test
+    func resetCountdown_pastDate() {
+        let now = Date(timeIntervalSince1970: 1_000_000)
+        let reset = now.addingTimeInterval(-10)
+        #expect(UsageFormatter.resetCountdownDescription(from: reset, now: now) == "now")
+    }
+
+    @Test
+    func modelDisplayNameStripsTrailingDates() {
+        #expect(UsageFormatter.modelDisplayName("claude-opus-4-5-20251101") == "claude-opus-4-5")
+        #expect(UsageFormatter.modelDisplayName("gpt-4o-2024-08-06") == "gpt-4o")
+        #expect(UsageFormatter.modelDisplayName("Claude Opus 4.5 2025 1101") == "Claude Opus 4.5")
+        #expect(UsageFormatter.modelDisplayName("claude-sonnet-4-5") == "claude-sonnet-4-5")
+    }
+
+    @Test
+    func cleanPlanMapsOAuthToOllama() {
+        #expect(UsageFormatter.cleanPlanName("oauth") == "Ollama")
+    }
+
+    @Test
+    func modelContextFromKnownModel() {
+        #expect(UsageFormatter.modelContextLabel(for: "gpt-4o") == "ctx 128K")
+        #expect(UsageFormatter.modelContextLabel(for: "claude-opus-4-5") == "ctx 200K")
+        #expect(UsageFormatter.modelContextLabel(for: "gpt-5") == "ctx 400K")
+        #expect(UsageFormatter.modelContextLabel(for: "gpt-5.2") == "ctx 400K")
+        #expect(UsageFormatter.modelContextLabel(for: "claude-opus-4-6") == "ctx 1M")
+        #expect(UsageFormatter.modelContextLabel(for: "claude-sonnet-4-6") == "ctx 1M")
+    }
+
+    @Test
+    func modelContextFromNameSuffix() {
+        #expect(UsageFormatter.modelContextWindow(for: "qwen2.5-128k-instruct") == 128_000)
+        #expect(UsageFormatter.modelContextLabel(for: "provider/qwen2.5-2m-long-context") == "ctx 2M")
+    }
+
+    @Test
+    func modelContextUnknownReturnsNil() {
+        #expect(UsageFormatter.modelContextWindow(for: "unknown-custom-model-v1") == nil)
+    }
+
+    @Test
+    func tokenSummaryIncludesBreakdown() {
+        let totals = UsageLedgerTotals(
+            inputTokens: 1000,
+            outputTokens: 200,
+            cacheCreationTokens: 300,
+            cacheReadTokens: 50,
+            costUSD: nil)
+        #expect(UsageFormatter.tokenSummaryString(totals) == "1.6K tok (in 1K, out 200, cache 350)")
+    }
+}

package/Tests/RunicTests/UsageLedgerAnomalyDetectionTests.swift

@@ -0,0 +1,172 @@
+import Foundation
+import RunicCore
+import Testing
+
+@testable import Runic
+
+@Suite
+struct UsageLedgerAnomalyDetectionTests {
+    @Test
+    func detectsTokenSpikeAgainstSevenDayBaseline() {
+        let now = Date(timeIntervalSince1970: 1_771_718_400) // 2026-02-22T00:00:00Z
+        var calendar = Calendar(identifier: .gregorian)
+        calendar.timeZone = TimeZone.current
+
+        var summaries: [UsageLedgerDailySummary] = []
+        for offset in -7 ... -1 {
+            summaries.append(self.dailySummary(
+                provider: .codex,
+                dayOffset: offset,
+                tokens: 1_000,
+                cost: nil,
+                now: now,
+                calendar: calendar))
+        }
+        summaries.append(self.dailySummary(
+            provider: .codex,
+            dayOffset: 0,
+            tokens: 2_500,
+            cost: nil,
+            now: now,
+            calendar: calendar))
+
+        let anomalies = UsageLedgerAnomalyDetector.summaries(
+            dailySummaries: summaries,
+            now: now,
+            calendar: calendar)
+
+        let codex = anomalies[.codex]
+        #expect(codex != nil)
+        #expect(codex?.tokenAnomaly?.metric == .tokens)
+        #expect(codex?.tokenAnomaly?.severity == .high)
+        #expect(codex?.spendAnomaly == nil)
+    }
+
+    @Test
+    func detectsSpendSpikeWhenCostDataExists() {
+        let now = Date(timeIntervalSince1970: 1_771_718_400) // 2026-02-22T00:00:00Z
+        var calendar = Calendar(identifier: .gregorian)
+        calendar.timeZone = TimeZone.current
+
+        var summaries: [UsageLedgerDailySummary] = []
+        for offset in -7 ... -1 {
+            summaries.append(self.dailySummary(
+                provider: .claude,
+                dayOffset: offset,
+                tokens: 1_000,
+                cost: 2.0,
+                now: now,
+                calendar: calendar))
+        }
+        summaries.append(self.dailySummary(
+            provider: .claude,
+            dayOffset: 0,
+            tokens: 1_100,
+            cost: 7.0,
+            now: now,
+            calendar: calendar))
+
+        let anomalies = UsageLedgerAnomalyDetector.summaries(
+            dailySummaries: summaries,
+            now: now,
+            calendar: calendar)
+
+        let claude = anomalies[.claude]
+        #expect(claude != nil)
+        #expect(claude?.tokenAnomaly == nil)
+        #expect(claude?.spendAnomaly?.metric == .spend)
+        #expect(claude?.spendAnomaly?.severity == .critical)
+    }
+
+    @Test
+    func doesNotEmitAnomalyWhenHistoryHasFewerThanSevenDays() {
+        let now = Date(timeIntervalSince1970: 1_771_718_400) // 2026-02-22T00:00:00Z
+        var calendar = Calendar(identifier: .gregorian)
+        calendar.timeZone = TimeZone.current
+
+        var summaries: [UsageLedgerDailySummary] = []
+        for offset in -3 ... -1 {
+            summaries.append(self.dailySummary(
+                provider: .codex,
+                dayOffset: offset,
+                tokens: 800,
+                cost: 1.0,
+                now: now,
+                calendar: calendar))
+        }
+        summaries.append(self.dailySummary(
+            provider: .codex,
+            dayOffset: 0,
+            tokens: 4_000,
+            cost: 8.0,
+            now: now,
+            calendar: calendar))
+
+        let anomalies = UsageLedgerAnomalyDetector.summaries(
+            dailySummaries: summaries,
+            now: now,
+            calendar: calendar)
+
+        #expect(anomalies[.codex] == nil)
+        #expect(anomalies.isEmpty)
+    }
+
+    @Test
+    func explanationIncludesHeadlineAndContributingFactors() {
+        let summary = UsageLedgerAnomalySummary(
+            provider: .codex,
+            baselineDays: 7,
+            tokenAnomaly: UsageLedgerAnomalySummary.MetricAnomaly(
+                metric: .tokens,
+                severity: .high,
+                todayValue: 4_200,
+                baselineAverage: 1_500,
+                percentIncrease: 1.8),
+            spendAnomaly: UsageLedgerAnomalySummary.MetricAnomaly(
+                metric: .spend,
+                severity: .elevated,
+                todayValue: 17.5,
+                baselineAverage: 9.0,
+                percentIncrease: 0.94))
+
+        let explanation = summary.explanation
+        #expect(explanation?.headline == "Anomaly: High tokens spike")
+        #expect(explanation?.details.count == 2)
+        #expect(explanation?.details.first?.contains("+180%") == true)
+        #expect(explanation?.details.last?.contains("+94%") == true)
+    }
+
+    @Test
+    func explanationIsNilWhenNoAnomaliesExist() {
+        let summary = UsageLedgerAnomalySummary(
+            provider: .codex,
+            baselineDays: 7,
+            tokenAnomaly: nil,
+            spendAnomaly: nil)
+        #expect(summary.explanation == nil)
+    }
+
+    private func dailySummary(
+        provider: UsageProvider,
+        dayOffset: Int,
+        tokens: Int,
+        cost: Double?,
+        now: Date,
+        calendar: Calendar) -> UsageLedgerDailySummary
+    {
+        let todayStart = calendar.startOfDay(for: now)
+        let dayStart = calendar.date(byAdding: .day, value: dayOffset, to: todayStart) ?? todayStart
+        return UsageLedgerDailySummary(
+            provider: provider,
+            projectID: nil,
+            dayStart: dayStart,
+            dayKey: "\(dayOffset)",
+            totals: UsageLedgerTotals(
+                inputTokens: tokens,
+                outputTokens: 0,
+                cacheCreationTokens: 0,
+                cacheReadTokens: 0,
+                costUSD: cost),
+            modelsUsed: ["gpt-5"])
+    }
+}

package/Tests/RunicTests/UsageLedgerForecastTests.swift

@@ -0,0 +1,213 @@
+import Foundation
+import Testing
+
+@testable import RunicCore
+
+@Suite
+struct UsageLedgerForecastTests {
+    private let utc = TimeZone(secondsFromGMT: 0)!
+
+    @Test
+    func providerForecastUsesObservedDaysInCurrentMonth() {
+        let now = self.date(year: 2026, month: 2, day: 20)
+        let entries = [
+            self.entry(
+                provider: .codex,
+                timestamp: self.date(year: 2026, month: 2, day: 1),
+                projectID: "proj-a",
+                projectName: "Project A",
+                costUSD: 10),
+            self.entry(
+                provider: .codex,
+                timestamp: self.date(year: 2026, month: 2, day: 2),
+                projectID: "proj-a",
+                projectName: "Project A",
+                costUSD: 20),
+            self.entry(
+                provider: .codex,
+                timestamp: self.date(year: 2026, month: 1, day: 31),
+                projectID: "proj-a",
+                projectName: "Project A",
+                costUSD: 99),
+        ]
+
+        let forecasts = UsageLedgerAggregator.providerSpendForecasts(
+            entries: entries,
+            now: now,
+            timeZone: self.utc,
+            projectionDays: 30)
+        let codex = forecasts.first { $0.provider == .codex }
+
+        #expect(codex != nil)
+        #expect(codex?.projectKey == nil)
+        #expect(codex?.observedDays == 2)
+        #expect(abs((codex?.observedCostUSD ?? 0) - 30) < 0.0001)
+        #expect(abs((codex?.averageDailyCostUSD ?? 0) - 15) < 0.0001)
+        #expect(abs((codex?.projected30DayCostUSD ?? 0) - 450) < 0.0001)
+        #expect(codex?.projectedCostP50USD == nil)
+        #expect(codex?.projectedCostP80USD == nil)
+        #expect(codex?.projectedCostP95USD == nil)
+    }
+
+    @Test
+    func projectForecastsAreComputedPerProject() {
+        let now = self.date(year: 2026, month: 2, day: 20)
+        let entries = [
+            self.entry(
+                provider: .codex,
+                timestamp: self.date(year: 2026, month: 2, day: 1),
+                projectID: "proj-a",
+                projectName: "Project A",
+                costUSD: 5),
+            self.entry(
+                provider: .codex,
+                timestamp: self.date(year: 2026, month: 2, day: 2),
+                projectID: "proj-a",
+                projectName: "Project A",
+                costUSD: 15),
+            self.entry(
+                provider: .codex,
+                timestamp: self.date(year: 2026, month: 2, day: 3),
+                projectID: "proj-b",
+                projectName: "Project B",
+                costUSD: 20),
+        ]
+
+        let forecasts = UsageLedgerAggregator.projectSpendForecasts(
+            entries: entries,
+            now: now,
+            timeZone: self.utc,
+            projectionDays: 30)
+
+        let projectA = forecasts.first { $0.projectID == "proj-a" }
+        let projectB = forecasts.first { $0.projectID == "proj-b" }
+
+        #expect(projectA != nil)
+        #expect(projectB != nil)
+        #expect(projectA?.observedDays == 2)
+        #expect(abs((projectA?.projected30DayCostUSD ?? 0) - 300) < 0.0001)
+        #expect(projectB?.observedDays == 1)
+        #expect(abs((projectB?.projected30DayCostUSD ?? 0) - 600) < 0.0001)
+    }
+
+    @Test
+    func providerForecastIncludesConfidenceBandQuantilesWhenEnoughDailyHistoryExists() {
+        let now = self.date(year: 2026, month: 2, day: 20)
+        let entries = [
+            self.entry(
+                provider: .codex,
+                timestamp: self.date(year: 2026, month: 2, day: 1),
+                projectID: "proj-a",
+                projectName: "Project A",
+                costUSD: 10),
+            self.entry(
+                provider: .codex,
+                timestamp: self.date(year: 2026, month: 2, day: 2),
+                projectID: "proj-a",
+                projectName: "Project A",
+                costUSD: 20),
+            self.entry(
+                provider: .codex,
+                timestamp: self.date(year: 2026, month: 2, day: 3),
+                projectID: "proj-a",
+                projectName: "Project A",
+                costUSD: 30),
+            self.entry(
+                provider: .codex,
+                timestamp: self.date(year: 2026, month: 2, day: 4),
+                projectID: "proj-a",
+                projectName: "Project A",
+                costUSD: 40),
+            self.entry(
+                provider: .codex,
+                timestamp: self.date(year: 2026, month: 2, day: 5),
+                projectID: "proj-a",
+                projectName: "Project A",
+                costUSD: 50),
+        ]
+
+        let forecasts = UsageLedgerAggregator.providerSpendForecasts(
+            entries: entries,
+            now: now,
+            timeZone: self.utc,
+            projectionDays: 30)
+        let codex = forecasts.first { $0.provider == .codex }
+
+        #expect(codex != nil)
+        #expect(abs((codex?.projectedCostP50USD ?? 0) - 900) < 0.0001)
+        #expect(abs((codex?.projectedCostP80USD ?? 0) - 1260) < 0.0001)
+        #expect(abs((codex?.projectedCostP95USD ?? 0) - 1440) < 0.0001)
+        #expect((codex?.projectedCostP95USD ?? 0) >= (codex?.projectedCostP80USD ?? 0))
+        #expect((codex?.projectedCostP80USD ?? 0) >= (codex?.projectedCostP50USD ?? 0))
+    }
+
+    @Test
+    func budgetETAIsComputedOnlyWhenForecastBreachesBudget() {
+        let base = UsageLedgerSpendForecast(
+            provider: .codex,
+            projectKey: "id:proj-a",
+            projectID: "proj-a",
+            projectName: "Project A",
+            observedDays: 5,
+            observedCostUSD: 50,
+            averageDailyCostUSD: 10,
+            projected30DayCostUSD: 300,
+            projectedCostP50USD: 270,
+            projectedCostP80USD: 330,
+            projectedCostP95USD: 390)
+
+        let breach = base.applyingBudget(monthlyLimitUSD: 90)
+        #expect(breach.budgetWillBreach)
+        #expect(breach.budgetLimitUSD == 90)
+        #expect(abs((breach.budgetETAInDays ?? 0) - 4) < 0.0001)
+        #expect(breach.projectedCostP50USD == 270)
+        #expect(breach.projectedCostP80USD == 330)
+        #expect(breach.projectedCostP95USD == 390)
+
+        let noBreach = base.applyingBudget(monthlyLimitUSD: 500)
+        #expect(!noBreach.budgetWillBreach)
+        #expect(noBreach.budgetLimitUSD == 500)
+        #expect(noBreach.budgetETAInDays == nil)
+
+        let alreadyBreached = base.applyingBudget(monthlyLimitUSD: 40)
+        #expect(alreadyBreached.budgetWillBreach)
+        #expect(alreadyBreached.budgetETAInDays == 0)
+    }
+
+    private func entry(
+        provider: UsageProvider,
+        timestamp: Date,
+        projectID: String?,
+        projectName: String?,
+        costUSD: Double?) -> UsageLedgerEntry
+    {
+        UsageLedgerEntry(
+            provider: provider,
+            timestamp: timestamp,
+            sessionID: "session",
+            projectID: projectID,
+            projectName: projectName,
+            model: "gpt-5",
+            inputTokens: 100,
+            outputTokens: 50,
+            cacheCreationTokens: 0,
+            cacheReadTokens: 0,
+            costUSD: costUSD,
+            requestID: UUID().uuidString,
+            messageID: nil,
+            version: nil,
+            source: .codexLog)
+    }
+
+    private func date(year: Int, month: Int, day: Int, hour: Int = 12) -> Date {
+        var calendar = Calendar(identifier: .gregorian)
+        calendar.timeZone = self.utc
+        return calendar.date(from: DateComponents(
+            calendar: calendar,
+            timeZone: self.utc,
+            year: year,
+            month: month,
+            day: day,
+            hour: hour))!
+    }
+}