@sriinnu/runic 1.0.0

package/Sources/RunicCore/Performance/PerformanceStorageImpl.swift

@@ -0,0 +1,409 @@
+import Foundation
+import SQLite3
+
+/// Storage layer for performance metrics using SQLite
+public final class PerformanceStorageImpl {
+
+    // MARK: - Properties
+
+    private var db: OpaquePointer?
+    private let dbPath: URL
+
+    // MARK: - Initialization
+
+    public init() {
+        let appSupport = FileManager.default.urls(
+            for: .applicationSupportDirectory,
+            in: .userDomainMask
+        ).first!
+        let runicDir = appSupport.appendingPathComponent("Runic")
+
+        // Ensure directory exists
+        try? FileManager.default.createDirectory(at: runicDir, withIntermediateDirectories: true)
+
+        self.dbPath = runicDir.appendingPathComponent("performance.db")
+    }
+
+    deinit {
+        if let db = db {
+            sqlite3_close(db)
+        }
+    }
+
+    // MARK: - Database Connection
+
+    private func open() throws {
+        guard db == nil else { return }
+
+        let flags = SQLITE_OPEN_CREATE | SQLITE_OPEN_READWRITE | SQLITE_OPEN_FULLMUTEX
+        let result = sqlite3_open_v2(dbPath.path, &db, flags, nil)
+
+        guard result == SQLITE_OK else {
+            throw StorageError.openFailed(message: String(cString: sqlite3_errmsg(db)))
+        }
+
+        try createTablesIfNeeded()
+    }
+
+    private func close() {
+        if let db = db {
+            sqlite3_close(db)
+            self.db = nil
+        }
+    }
+
+    // MARK: - Schema Creation
+
+    private func createTablesIfNeeded() throws {
+        let schemas = [
+            """
+            CREATE TABLE IF NOT EXISTS latency_metrics (
+                id TEXT PRIMARY KEY,
+                request_id TEXT NOT NULL,
+                provider TEXT NOT NULL,
+                model TEXT,
+                start_time REAL NOT NULL,
+                end_time REAL NOT NULL,
+                duration_ms INTEGER NOT NULL,
+                success INTEGER NOT NULL,
+                created_at REAL NOT NULL
+            )
+            """,
+            """
+            CREATE TABLE IF NOT EXISTS quality_ratings (
+                id TEXT PRIMARY KEY,
+                request_id TEXT NOT NULL,
+                provider TEXT NOT NULL,
+                model TEXT,
+                rating INTEGER NOT NULL,
+                comment TEXT,
+                timestamp REAL NOT NULL
+            )
+            """,
+            """
+            CREATE TABLE IF NOT EXISTS error_events (
+                id TEXT PRIMARY KEY,
+                provider TEXT NOT NULL,
+                error_type TEXT NOT NULL,
+                error_message TEXT,
+                retry_count INTEGER NOT NULL,
+                timestamp REAL NOT NULL
+            )
+            """,
+            """
+            CREATE TABLE IF NOT EXISTS daily_stats (
+                provider TEXT NOT NULL,
+                model TEXT,
+                date TEXT NOT NULL,
+                total_requests INTEGER NOT NULL,
+                avg_latency_ms INTEGER NOT NULL,
+                p50_latency_ms INTEGER NOT NULL,
+                p95_latency_ms INTEGER NOT NULL,
+                p99_latency_ms INTEGER NOT NULL,
+                avg_quality_rating REAL NOT NULL,
+                total_ratings INTEGER NOT NULL,
+                rating_1_count INTEGER NOT NULL,
+                rating_2_count INTEGER NOT NULL,
+                rating_3_count INTEGER NOT NULL,
+                rating_4_count INTEGER NOT NULL,
+                rating_5_count INTEGER NOT NULL,
+                error_count INTEGER NOT NULL,
+                error_rate REAL NOT NULL,
+                timeout_count INTEGER NOT NULL,
+                quota_count INTEGER NOT NULL,
+                network_count INTEGER NOT NULL,
+                api_error_count INTEGER NOT NULL,
+                created_at REAL NOT NULL,
+                PRIMARY KEY (provider, model, date)
+            )
+            """,
+            "CREATE INDEX IF NOT EXISTS idx_latency_created ON latency_metrics(created_at)",
+            "CREATE INDEX IF NOT EXISTS idx_quality_timestamp ON quality_ratings(timestamp)",
+            "CREATE INDEX IF NOT EXISTS idx_error_timestamp ON error_events(timestamp)",
+            "CREATE INDEX IF NOT EXISTS idx_daily_stats_date ON daily_stats(date)"
+        ]
+
+        for schema in schemas {
+            try execute(schema)
+        }
+    }
+
+    // MARK: - Execute SQL
+
+    private func execute(_ sql: String) throws {
+        guard let db = db else {
+            throw StorageError.notOpen
+        }
+
+        var errorMessage: UnsafeMutablePointer<CChar>?
+        let result = sqlite3_exec(db, sql, nil, nil, &errorMessage)
+
+        if result != SQLITE_OK {
+            let message = errorMessage.map { String(cString: $0) } ?? "Unknown error"
+            sqlite3_free(errorMessage)
+            throw StorageError.executionFailed(message: message)
+        }
+    }
+
+    // MARK: - Save Metrics
+
+    public func save(latency: LatencyMetric) async throws {
+        try open()
+
+        let sql = """
+            INSERT OR REPLACE INTO latency_metrics
+            (id, request_id, provider, model, start_time, end_time, duration_ms, success, created_at)
+            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+            """
+
+        var statement: OpaquePointer?
+        defer { sqlite3_finalize(statement) }
+
+        guard sqlite3_prepare_v2(db, sql, -1, &statement, nil) == SQLITE_OK else {
+            throw StorageError.prepareFailed(message: String(cString: sqlite3_errmsg(db)))
+        }
+
+        sqlite3_bind_text(statement, 1, latency.id, -1, unsafeBitCast(-1, to: sqlite3_destructor_type.self))
+        sqlite3_bind_text(statement, 2, latency.requestID, -1, unsafeBitCast(-1, to: sqlite3_destructor_type.self))
+        sqlite3_bind_text(statement, 3, latency.provider.rawValue, -1, unsafeBitCast(-1, to: sqlite3_destructor_type.self))
+
+        if let model = latency.model {
+            sqlite3_bind_text(statement, 4, model, -1, unsafeBitCast(-1, to: sqlite3_destructor_type.self))
+        } else {
+            sqlite3_bind_null(statement, 4)
+        }
+
+        sqlite3_bind_double(statement, 5, latency.startTime.timeIntervalSince1970)
+        sqlite3_bind_double(statement, 6, latency.endTime.timeIntervalSince1970)
+        sqlite3_bind_int(statement, 7, Int32(latency.durationMs))
+        sqlite3_bind_int(statement, 8, latency.success ? 1 : 0)
+        sqlite3_bind_double(statement, 9, latency.createdAt.timeIntervalSince1970)
+
+        guard sqlite3_step(statement) == SQLITE_DONE else {
+            throw StorageError.insertFailed(message: String(cString: sqlite3_errmsg(db)))
+        }
+    }
+
+    public func save(rating: QualityRating) async throws {
+        try open()
+
+        let sql = """
+            INSERT OR REPLACE INTO quality_ratings
+            (id, request_id, provider, model, rating, comment, timestamp)
+            VALUES (?, ?, ?, ?, ?, ?, ?)
+            """
+
+        var statement: OpaquePointer?
+        defer { sqlite3_finalize(statement) }
+
+        guard sqlite3_prepare_v2(db, sql, -1, &statement, nil) == SQLITE_OK else {
+            throw StorageError.prepareFailed(message: String(cString: sqlite3_errmsg(db)))
+        }
+
+        sqlite3_bind_text(statement, 1, rating.id, -1, unsafeBitCast(-1, to: sqlite3_destructor_type.self))
+        sqlite3_bind_text(statement, 2, rating.requestID, -1, unsafeBitCast(-1, to: sqlite3_destructor_type.self))
+        sqlite3_bind_text(statement, 3, rating.provider.rawValue, -1, unsafeBitCast(-1, to: sqlite3_destructor_type.self))
+
+        if let model = rating.model {
+            sqlite3_bind_text(statement, 4, model, -1, unsafeBitCast(-1, to: sqlite3_destructor_type.self))
+        } else {
+            sqlite3_bind_null(statement, 4)
+        }
+
+        sqlite3_bind_int(statement, 5, Int32(rating.rating))
+
+        if let comment = rating.comment {
+            sqlite3_bind_text(statement, 6, comment, -1, unsafeBitCast(-1, to: sqlite3_destructor_type.self))
+        } else {
+            sqlite3_bind_null(statement, 6)
+        }
+
+        sqlite3_bind_double(statement, 7, rating.timestamp.timeIntervalSince1970)
+
+        guard sqlite3_step(statement) == SQLITE_DONE else {
+            throw StorageError.insertFailed(message: String(cString: sqlite3_errmsg(db)))
+        }
+    }
+
+    public func save(error: ErrorEvent) async throws {
+        try open()
+
+        let sql = """
+            INSERT OR REPLACE INTO error_events
+            (id, provider, error_type, error_message, retry_count, timestamp)
+            VALUES (?, ?, ?, ?, ?, ?)
+            """
+
+        var statement: OpaquePointer?
+        defer { sqlite3_finalize(statement) }
+
+        guard sqlite3_prepare_v2(db, sql, -1, &statement, nil) == SQLITE_OK else {
+            throw StorageError.prepareFailed(message: String(cString: sqlite3_errmsg(db)))
+        }
+
+        sqlite3_bind_text(statement, 1, error.id, -1, unsafeBitCast(-1, to: sqlite3_destructor_type.self))
+        sqlite3_bind_text(statement, 2, error.provider.rawValue, -1, unsafeBitCast(-1, to: sqlite3_destructor_type.self))
+        sqlite3_bind_text(statement, 3, error.errorType.rawValue, -1, unsafeBitCast(-1, to: sqlite3_destructor_type.self))
+
+        if let message = error.errorMessage {
+            sqlite3_bind_text(statement, 4, message, -1, unsafeBitCast(-1, to: sqlite3_destructor_type.self))
+        } else {
+            sqlite3_bind_null(statement, 4)
+        }
+
+        sqlite3_bind_int(statement, 5, Int32(error.retryCount))
+        sqlite3_bind_double(statement, 6, error.timestamp.timeIntervalSince1970)
+
+        guard sqlite3_step(statement) == SQLITE_DONE else {
+            throw StorageError.insertFailed(message: String(cString: sqlite3_errmsg(db)))
+        }
+    }
+
+    // MARK: - Fetch Daily Stats
+
+    public func fetchDailyStats(
+        timeRange: Int,
+        provider: UsageProvider? = nil,
+        model: String? = nil
+    ) async throws -> [DailyPerformanceStats] {
+        try open()
+
+        var sql = "SELECT * FROM daily_stats WHERE date >= date('now', '-\(timeRange) days')"
+
+        if let provider = provider {
+            sql += " AND provider = '\(provider.rawValue)'"
+        }
+
+        if let model = model {
+            sql += " AND model = '\(model)'"
+        }
+
+        sql += " ORDER BY date DESC"
+
+        var statement: OpaquePointer?
+        defer { sqlite3_finalize(statement) }
+
+        guard sqlite3_prepare_v2(db, sql, -1, &statement, nil) == SQLITE_OK else {
+            throw StorageError.prepareFailed(message: String(cString: sqlite3_errmsg(db)))
+        }
+
+        var stats: [DailyPerformanceStats] = []
+
+        while sqlite3_step(statement) == SQLITE_ROW {
+            let provider = String(cString: sqlite3_column_text(statement, 0))
+            let model = sqlite3_column_type(statement, 1) == SQLITE_NULL
+                ? nil
+                : String(cString: sqlite3_column_text(statement, 1))
+            let date = String(cString: sqlite3_column_text(statement, 2))
+            let totalRequests = Int(sqlite3_column_int(statement, 3))
+            let avgLatencyMs = Int(sqlite3_column_int(statement, 4))
+            let p50LatencyMs = Int(sqlite3_column_int(statement, 5))
+            let p95LatencyMs = Int(sqlite3_column_int(statement, 6))
+            let p99LatencyMs = Int(sqlite3_column_int(statement, 7))
+            let avgQualityRating = sqlite3_column_double(statement, 8)
+            let totalRatings = Int(sqlite3_column_int(statement, 9))
+            let rating1Count = Int(sqlite3_column_int(statement, 10))
+            let rating2Count = Int(sqlite3_column_int(statement, 11))
+            let rating3Count = Int(sqlite3_column_int(statement, 12))
+            let rating4Count = Int(sqlite3_column_int(statement, 13))
+            let rating5Count = Int(sqlite3_column_int(statement, 14))
+            let errorCount = Int(sqlite3_column_int(statement, 15))
+            let errorRate = sqlite3_column_double(statement, 16)
+            let timeoutCount = Int(sqlite3_column_int(statement, 17))
+            let quotaCount = Int(sqlite3_column_int(statement, 18))
+            let networkCount = Int(sqlite3_column_int(statement, 19))
+            let apiErrorCount = Int(sqlite3_column_int(statement, 20))
+            let createdAt = Date(timeIntervalSince1970: sqlite3_column_double(statement, 21))
+
+            let stat = DailyPerformanceStats(
+                provider: provider,
+                model: model,
+                date: date,
+                totalRequests: totalRequests,
+                avgLatencyMs: avgLatencyMs,
+                p50LatencyMs: p50LatencyMs,
+                p95LatencyMs: p95LatencyMs,
+                p99LatencyMs: p99LatencyMs,
+                avgQualityRating: avgQualityRating,
+                totalRatings: totalRatings,
+                rating1Count: rating1Count,
+                rating2Count: rating2Count,
+                rating3Count: rating3Count,
+                rating4Count: rating4Count,
+                rating5Count: rating5Count,
+                errorCount: errorCount,
+                errorRate: errorRate,
+                timeoutCount: timeoutCount,
+                quotaCount: quotaCount,
+                networkCount: networkCount,
+                apiErrorCount: apiErrorCount,
+                createdAt: createdAt
+            )
+
+            stats.append(stat)
+        }
+
+        return stats
+    }
+
+    // MARK: - Database Maintenance
+
+    public func vacuum() async throws {
+        try open()
+        try execute("VACUUM")
+    }
+
+    public func deleteOldData(olderThan days: Int) async throws {
+        try open()
+
+        let cutoffDate = Date().addingTimeInterval(-Double(days) * 24 * 60 * 60)
+        let cutoffTimestamp = cutoffDate.timeIntervalSince1970
+
+        let queries = [
+            "DELETE FROM latency_metrics WHERE created_at < \(cutoffTimestamp)",
+            "DELETE FROM quality_ratings WHERE timestamp < \(cutoffTimestamp)",
+            "DELETE FROM error_events WHERE timestamp < \(cutoffTimestamp)"
+        ]
+
+        for query in queries {
+            try execute(query)
+        }
+    }
+
+    // MARK: - Error Types
+
+    public enum StorageError: Error, LocalizedError {
+        case notOpen
+        case openFailed(message: String)
+        case prepareFailed(message: String)
+        case executionFailed(message: String)
+        case insertFailed(message: String)
+
+        public var errorDescription: String? {
+            switch self {
+            case .notOpen:
+                return "Database not open"
+            case .openFailed(let message):
+                return "Failed to open database: \(message)"
+            case .prepareFailed(let message):
+                return "Failed to prepare statement: \(message)"
+            case .executionFailed(let message):
+                return "Failed to execute statement: \(message)"
+            case .insertFailed(let message):
+                return "Failed to insert data: \(message)"
+            }
+        }
+    }
+}
+
+// MARK: - Helper Extensions
+
+extension String {
+    fileprivate init(cString pointer: UnsafePointer<UInt8>?) {
+        guard let pointer = pointer else {
+            self = ""
+            return
+        }
+        self = String(cString: pointer)
+    }
+}

package/Sources/RunicCore/Policy/UsagePolicyEngine.swift

@@ -0,0 +1,178 @@
+import Foundation
+
+public enum UsagePolicyAction: String, Sendable, Codable, Hashable, CaseIterable {
+    case none
+    case warn
+    case softLimit
+    case hardStop
+
+    var severityRank: Int {
+        switch self {
+        case .none: 0
+        case .warn: 1
+        case .softLimit: 2
+        case .hardStop: 3
+        }
+    }
+}
+
+public enum UsagePolicyAnomalySeverity: Int, Sendable, Codable, Hashable {
+    case elevated = 1
+    case high = 2
+    case critical = 3
+}
+
+public struct UsagePolicyContext: Sendable, Codable, Hashable {
+    public let provider: UsageProvider
+    public let observedSpendUSD: Double?
+    public let projectedSpendUSD: Double?
+    public let budgetLimitUSD: Double?
+    public let anomalySeverity: UsagePolicyAnomalySeverity?
+
+    public init(
+        provider: UsageProvider,
+        observedSpendUSD: Double?,
+        projectedSpendUSD: Double?,
+        budgetLimitUSD: Double?,
+        anomalySeverity: UsagePolicyAnomalySeverity? = nil)
+    {
+        self.provider = provider
+        self.observedSpendUSD = observedSpendUSD
+        self.projectedSpendUSD = projectedSpendUSD
+        self.budgetLimitUSD = budgetLimitUSD
+        self.anomalySeverity = anomalySeverity
+    }
+}
+
+public enum UsagePolicyCondition: Sendable, Codable, Hashable {
+    case projectedBudgetOverrun(minimumPercent: Double)
+    case actualBudgetOverrun
+    case anomalySeverityAtLeast(UsagePolicyAnomalySeverity)
+}
+
+public struct UsagePolicyRule: Sendable, Codable, Hashable, Identifiable {
+    public let id: String
+    public let name: String
+    public let enabled: Bool
+    public let condition: UsagePolicyCondition
+    public let action: UsagePolicyAction
+
+    public init(
+        id: String = UUID().uuidString,
+        name: String,
+        enabled: Bool = true,
+        condition: UsagePolicyCondition,
+        action: UsagePolicyAction)
+    {
+        self.id = id
+        self.name = name
+        self.enabled = enabled
+        self.condition = condition
+        self.action = action
+    }
+}
+
+public struct UsagePolicyRuleMatch: Sendable, Codable, Hashable {
+    public let ruleID: String
+    public let ruleName: String
+    public let action: UsagePolicyAction
+    public let reason: String
+
+    public init(ruleID: String, ruleName: String, action: UsagePolicyAction, reason: String) {
+        self.ruleID = ruleID
+        self.ruleName = ruleName
+        self.action = action
+        self.reason = reason
+    }
+}
+
+public struct UsagePolicyDecision: Sendable, Codable, Hashable {
+    public let action: UsagePolicyAction
+    public let matches: [UsagePolicyRuleMatch]
+    public let reasons: [String]
+
+    public init(action: UsagePolicyAction, matches: [UsagePolicyRuleMatch], reasons: [String]) {
+        self.action = action
+        self.matches = matches
+        self.reasons = reasons
+    }
+
+    public var shouldThrottle: Bool {
+        self.action.severityRank >= UsagePolicyAction.softLimit.severityRank
+    }
+
+    public var shouldBlock: Bool {
+        self.action == .hardStop
+    }
+}
+
+public enum UsagePolicyEngine {
+    public static func evaluate(
+        context: UsagePolicyContext,
+        rules: [UsagePolicyRule]) -> UsagePolicyDecision
+    {
+        var matches: [UsagePolicyRuleMatch] = []
+        matches.reserveCapacity(rules.count)
+
+        for rule in rules where rule.enabled {
+            guard let reason = self.matchReason(for: rule.condition, context: context) else { continue }
+            matches.append(UsagePolicyRuleMatch(
+                ruleID: rule.id,
+                ruleName: rule.name,
+                action: rule.action,
+                reason: reason))
+        }
+
+        guard !matches.isEmpty else {
+            return UsagePolicyDecision(
+                action: .none,
+                matches: [],
+                reasons: ["No policy rules matched."])
+        }
+
+        let strongestAction = matches
+            .map(\.action)
+            .max { $0.severityRank < $1.severityRank } ?? .none
+
+        return UsagePolicyDecision(
+            action: strongestAction,
+            matches: matches,
+            reasons: matches.map(\.reason))
+    }
+
+    private static func matchReason(
+        for condition: UsagePolicyCondition,
+        context: UsagePolicyContext) -> String?
+    {
+        switch condition {
+        case .projectedBudgetOverrun(let minimumPercent):
+            guard let budget = context.budgetLimitUSD, budget > 0 else { return nil }
+            guard let projected = context.projectedSpendUSD, projected.isFinite else { return nil }
+            let overrunUSD = projected - budget
+            guard overrunUSD > 0 else { return nil }
+            let overrunPercent = overrunUSD / budget
+            guard overrunPercent >= max(0, minimumPercent) else { return nil }
+            let percentText = "\(Int((overrunPercent * 100).rounded()))%"
+            return "Projected spend \(UsageFormatter.usdString(projected)) is \(percentText) over budget \(UsageFormatter.usdString(budget))."
+
+        case .actualBudgetOverrun:
+            guard let budget = context.budgetLimitUSD, budget > 0 else { return nil }
+            guard let observed = context.observedSpendUSD, observed.isFinite else { return nil }
+            guard observed >= budget else { return nil }
+            return "Observed spend \(UsageFormatter.usdString(observed)) reached budget \(UsageFormatter.usdString(budget))."
+
+        case .anomalySeverityAtLeast(let required):
+            guard let observed = context.anomalySeverity else { return nil }
+            guard observed.rawValue >= required.rawValue else { return nil }
+            return "Anomaly severity \(self.severityLabel(observed)) meets threshold \(self.severityLabel(required))."
+        }
+    }
+
+    private static func severityLabel(_ severity: UsagePolicyAnomalySeverity) -> String {
+        switch severity {
+        case .elevated: "Elevated"
+        case .high: "High"
+        case .critical: "Critical"
+        }
+    }
+}

package/Sources/RunicCore/ProjectBudgetStore.swift

@@ -0,0 +1,99 @@
+import Foundation
+import RunicCore
+
+/// Storage for project budget limits and alert thresholds
+public struct ProjectBudgetStore {
+    // MARK: - Types
+
+    public struct ProjectBudget: Codable, Sendable, Identifiable {
+        public var id: String { projectID }
+        public let projectID: String
+        public var projectName: String?
+        public var monthlyLimit: Double
+        public var alertThreshold: Double // 0.0-1.0, default 0.8 (80%)
+        public var enabled: Bool
+        public let createdAt: Date
+
+        public init(
+            projectID: String,
+            projectName: String? = nil,
+            monthlyLimit: Double,
+            alertThreshold: Double = 0.8,
+            enabled: Bool = true,
+            createdAt: Date = Date()
+        ) {
+            self.projectID = projectID
+            self.projectName = projectName
+            self.monthlyLimit = monthlyLimit
+            self.alertThreshold = alertThreshold
+            self.enabled = enabled
+            self.createdAt = createdAt
+        }
+    }
+
+    public struct BudgetsData: Codable {
+        public let version: Int
+        public var budgets: [String: ProjectBudget] // projectID -> budget
+
+        public init(version: Int = 1, budgets: [String: ProjectBudget] = [:]) {
+            self.version = version
+            self.budgets = budgets
+        }
+    }
+
+    // MARK: - Storage Location
+
+    private static var storageURL: URL {
+        let appSupport = FileManager.default.urls(for: .applicationSupportDirectory, in: .userDomainMask)[0]
+        let runicDir = appSupport.appendingPathComponent("Runic", isDirectory: true)
+        try? FileManager.default.createDirectory(at: runicDir, withIntermediateDirectories: true)
+        return runicDir.appendingPathComponent("project-budgets.json")
+    }
+
+    // MARK: - Public Methods
+
+    public static func load() -> BudgetsData {
+        guard FileManager.default.fileExists(atPath: storageURL.path) else {
+            return BudgetsData()
+        }
+
+        do {
+            let data = try Data(contentsOf: storageURL)
+            let decoder = JSONDecoder()
+            decoder.dateDecodingStrategy = .iso8601
+            return try decoder.decode(BudgetsData.self, from: data)
+        } catch {
+            print("[ProjectBudgetStore] Failed to load budgets: \(error)")
+            return BudgetsData()
+        }
+    }
+
+    public static func save(_ budgetsData: BudgetsData) throws {
+        let encoder = JSONEncoder()
+        encoder.dateEncodingStrategy = .iso8601
+        encoder.outputFormatting = [.prettyPrinted, .sortedKeys]
+
+        let data = try encoder.encode(budgetsData)
+        try data.write(to: storageURL, options: .atomic)
+    }
+
+    public static func getBudget(projectID: String) -> ProjectBudget? {
+        load().budgets[projectID]
+    }
+
+    public static func setBudget(_ budget: ProjectBudget) throws {
+        var data = load()
+        data.budgets[budget.projectID] = budget
+        try save(data)
+    }
+
+    public static func removeBudget(projectID: String) throws {
+        var data = load()
+        data.budgets.removeValue(forKey: projectID)
+        try save(data)
+    }
+
+    public static func getAllBudgets() -> [ProjectBudget] {
+        Array(load().budgets.values).sorted { $0.createdAt < $1.createdAt }
+    }
+}