@sriinnu/runic 2.0.0 → 2.11.2

package/Tests/RunicTests/TeamShowbackExporterTests.swift

@@ -1,157 +0,0 @@
-import Foundation
-import Testing
-@testable import RunicCore
-
-struct TeamShowbackExporterTests {
-    @Test
-    func `builds showback report for team owned projects`() 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 `exports json and csv from report`() 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

@@ -1,11 +0,0 @@
-import RunicCore
-import Testing
-
-struct TextParsingTests {
-    @Test
-    func `strip ANSI codes removes cursor visibility CSI`() {
-        let input = "\u{001B}[?25hhello\u{001B}[0m"
-        let stripped = TextParsing.stripANSICodes(input)
-        #expect(stripped == "hello")
-    }
-}

package/Tests/RunicTests/UsageFormatterTests.swift

@@ -1,111 +0,0 @@
-import Foundation
-import RunicCore
-import Testing
-@testable import Runic
-
-struct UsageFormatterTests {
-    @Test
-    func `formats usage line`() {
-        let line = UsageFormatter.usageLine(remaining: 25, used: 75)
-        #expect(line == "25% left")
-    }
-
-    @Test
-    func `relative updated recent`() {
-        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 `absolute updated old`() {
-        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 `reset countdown 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 `reset countdown hours and minutes`() {
-        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 `reset countdown days and hours`() {
-        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 `reset countdown exact hour`() {
-        let now = Date(timeIntervalSince1970: 1_000_000)
-        let reset = now.addingTimeInterval(60 * 60)
-        #expect(UsageFormatter.resetCountdownDescription(from: reset, now: now) == "in 1h")
-    }
-
-    @Test
-    func `reset countdown past date`() {
-        let now = Date(timeIntervalSince1970: 1_000_000)
-        let reset = now.addingTimeInterval(-10)
-        #expect(UsageFormatter.resetCountdownDescription(from: reset, now: now) == "now")
-    }
-
-    @Test
-    func `model display name strips trailing dates`() {
-        #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 `clean plan maps O auth to ollama`() {
-        #expect(UsageFormatter.cleanPlanName("oauth") == "Ollama")
-    }
-
-    @Test
-    func `model context from known model`() {
-        #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 `model context from name suffix`() {
-        #expect(UsageFormatter.modelContextWindow(for: "qwen2.5-128k-instruct") == 128_000)
-        #expect(UsageFormatter.modelContextLabel(for: "provider/qwen2.5-2m-long-context") == "ctx 2M")
-    }
-
-    @Test
-    func `model context unknown returns nil`() {
-        #expect(UsageFormatter.modelContextWindow(for: "unknown-custom-model-v1") == nil)
-    }
-
-    @Test
-    func `token summary includes breakdown`() {
-        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

@@ -1,170 +0,0 @@
-import Foundation
-import RunicCore
-import Testing
-@testable import Runic
-
-struct UsageLedgerAnomalyDetectionTests {
-    @Test
-    func `detects token spike against seven day baseline`() {
-        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: 1000,
-                cost: nil,
-                now: now,
-                calendar: calendar))
-        }
-        summaries.append(self.dailySummary(
-            provider: .codex,
-            dayOffset: 0,
-            tokens: 2500,
-            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 `detects spend spike when cost data exists`() {
-        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: 1000,
-                cost: 2.0,
-                now: now,
-                calendar: calendar))
-        }
-        summaries.append(self.dailySummary(
-            provider: .claude,
-            dayOffset: 0,
-            tokens: 1100,
-            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 `does not emit anomaly when history has fewer than seven days`() {
-        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: 4000,
-            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 `explanation includes headline and contributing factors`() {
-        let summary = UsageLedgerAnomalySummary(
-            provider: .codex,
-            baselineDays: 7,
-            tokenAnomaly: UsageLedgerAnomalySummary.MetricAnomaly(
-                metric: .tokens,
-                severity: .high,
-                todayValue: 4200,
-                baselineAverage: 1500,
-                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 `explanation is nil when no anomalies exist`() {
-        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

@@ -1,211 +0,0 @@
-import Foundation
-import Testing
-@testable import RunicCore
-
-struct UsageLedgerForecastTests {
-    private let utc = TimeZone(secondsFromGMT: 0)!
-
-    @Test
-    func `provider forecast uses observed days in current month`() {
-        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 `project forecasts are computed per project`() {
-        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 `provider forecast includes confidence band quantiles when enough daily history exists`() {
-        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 `budget ETA is computed only when forecast breaches budget`() {
-        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))!
-    }
-}