@sriinnu/runic 2.0.0 → 2.11.1

package/Sources/RunicCore/UsageLedger/UsageLedgerProjectIdentity.swift

@@ -1,284 +0,0 @@
-import Foundation
-
-public enum UsageLedgerProjectNameConfidence: String, Sendable, Codable {
-    case none
-    case low
-    case medium
-    case high
-
-    var rank: Int {
-        switch self {
-        case .none: 0
-        case .low: 1
-        case .medium: 2
-        case .high: 3
-        }
-    }
-}
-
-public enum UsageLedgerProjectNameSource: String, Sendable, Codable {
-    case unknown
-    case projectName
-    case projectID
-    case inferredFromPath
-    case inferredFromName
-    case budgetOverride
-}
-
-public struct UsageLedgerProjectIdentity: Sendable, Codable, Hashable {
-    public let key: String?
-    public let projectID: String?
-    public let displayName: String?
-    public let confidence: UsageLedgerProjectNameConfidence
-    public let source: UsageLedgerProjectNameSource
-    public let workspaceHash: String?
-    public let provenance: String?
-
-    public init(
-        key: String?,
-        projectID: String?,
-        displayName: String?,
-        confidence: UsageLedgerProjectNameConfidence,
-        source: UsageLedgerProjectNameSource,
-        workspaceHash: String?,
-        provenance: String?)
-    {
-        self.key = key
-        self.projectID = projectID
-        self.displayName = displayName
-        self.confidence = confidence
-        self.source = source
-        self.workspaceHash = workspaceHash
-        self.provenance = provenance
-    }
-}
-
-public enum UsageLedgerProjectIdentityResolver {
-    public static func resolve(
-        provider _: UsageProvider,
-        projectID: String?,
-        projectName: String?,
-        budgetNameOverride: String? = nil) -> UsageLedgerProjectIdentity
-    {
-        let normalizedProjectID = self.normalizedIdentifier(projectID)
-        let normalizedProjectName = self.normalizedDisplay(projectName)
-        let budgetName = self.normalizedDisplay(budgetNameOverride)
-        let workspaceCandidate = self.firstPathLikeValue(candidates: [projectID, projectName])
-        let workspaceHash = workspaceCandidate.map(self.stablePathHash)
-        let workspaceSuffix = workspaceHash.map { "#w:\($0.prefix(8))" } ?? ""
-
-        var displayName: String?
-        var confidence: UsageLedgerProjectNameConfidence = .none
-        var source: UsageLedgerProjectNameSource = .unknown
-        var provenance: String?
-
-        if let budgetName {
-            displayName = budgetName
-            confidence = .high
-            source = .budgetOverride
-            provenance = "budget_override"
-        } else if let normalizedProjectName {
-            displayName = normalizedProjectName
-            confidence = .high
-            source = .projectName
-            provenance = "entry.projectName"
-        } else if let pathTail = inferredPathTail(from: projectID) {
-            displayName = pathTail
-            confidence = .medium
-            source = .inferredFromPath
-            provenance = "path_tail(projectID)"
-        } else if let readableID = readableIdentifier(normalizedProjectID) {
-            displayName = readableID
-            confidence = .low
-            source = .projectID
-            provenance = "entry.projectID"
-        } else if let inferredFromName = inferredNameToken(from: projectName) {
-            displayName = inferredFromName
-            confidence = .low
-            source = .inferredFromName
-            provenance = "inferred(projectName)"
-        }
-
-        let key: String?
-        if let normalizedProjectID {
-            key = "id:\(normalizedProjectID.lowercased())\(workspaceSuffix)"
-        } else if let seed = displayName {
-            let slug = self.slugify(seed)
-            key = slug.isEmpty ? nil : "name:\(slug)\(workspaceSuffix)"
-        } else {
-            key = nil
-        }
-
-        return UsageLedgerProjectIdentity(
-            key: key,
-            projectID: normalizedProjectID,
-            displayName: displayName,
-            confidence: confidence,
-            source: source,
-            workspaceHash: workspaceHash,
-            provenance: provenance)
-    }
-
-    public static func fallbackDisplayName(projectID: String?) -> String? {
-        if let tail = inferredPathTail(from: projectID) {
-            return tail
-        }
-        guard let normalized = normalizedIdentifier(projectID), !normalized.isEmpty else {
-            return nil
-        }
-        if normalized.contains("/") || normalized.contains("\\") {
-            return nil
-        }
-        return self.readableIdentifier(normalized)
-    }
-
-    private static func normalizedIdentifier(_ value: String?) -> String? {
-        let cleaned = self.normalizedDisplay(value)
-        guard let cleaned, !cleaned.isEmpty else { return nil }
-        return cleaned
-    }
-
-    private static func normalizedDisplay(_ value: String?) -> String? {
-        guard let value else { return nil }
-        let trimmed = value.trimmingCharacters(in: .whitespacesAndNewlines)
-        guard !trimmed.isEmpty else { return nil }
-        let pieces = trimmed.split(whereSeparator: { $0.isWhitespace })
-        guard !pieces.isEmpty else { return nil }
-        return pieces.joined(separator: " ")
-    }
-
-    private static func inferredPathTail(from value: String?) -> String? {
-        guard let value else { return nil }
-
-        // Claude Code uses dash-separated path IDs like "-Users-srinivaspendela-Sriinnu-AI-Runic".
-        // Extract the last meaningful segment(s) as the project name.
-        if value.hasPrefix("-Users-") || value.hasPrefix("-home-") {
-            let parts = value.split(separator: "-").map(String.init)
-            // Find the last non-user-path segment — skip Users, username, common dirs
-            let skipPrefixes: Set = [
-                "Users",
-                "home",
-                "Documents",
-                "Desktop",
-                "Projects",
-                "Personal",
-                "repos",
-                "code",
-                "src",
-                "dev",
-                "Work",
-                "Sites",
-            ]
-            var meaningful: [String] = []
-            var pastUserPath = false
-            for part in parts where !part.isEmpty {
-                if !pastUserPath {
-                    if skipPrefixes.contains(part) || part.count <= 2 { continue }
-                    pastUserPath = true
-                }
-                meaningful.append(part)
-            }
-            // Take the last 1-2 segments as the project name
-            if meaningful.count >= 2 {
-                return meaningful.suffix(2).joined(separator: "/")
-            } else if let last = meaningful.last {
-                return last
-            }
-        }
-
-        let separators = CharacterSet(charactersIn: "/\\")
-        guard value.rangeOfCharacter(from: separators) != nil else { return nil }
-
-        let parts = value.split { ch in
-            ch == "/" || ch == "\\"
-        }
-        guard let last = parts.last else { return nil }
-        let tail = self.normalizedDisplay(String(last))
-        guard let tail else { return nil }
-        guard !self.looksOpaqueIdentifier(tail) else { return nil }
-        return tail
-    }
-
-    private static func readableIdentifier(_ value: String?) -> String? {
-        guard let value else { return nil }
-        guard !value.isEmpty else { return nil }
-        guard !self.looksOpaqueIdentifier(value) else { return nil }
-        return value
-    }
-
-    private static func inferredNameToken(from value: String?) -> String? {
-        let normalized = self.normalizedDisplay(value)
-        guard let normalized, !normalized.isEmpty else { return nil }
-        let slug = self.slugify(normalized)
-        guard !slug.isEmpty else { return nil }
-        let titleCased = slug.split(separator: "-")
-            .map { token -> String in
-                guard let first = token.first else { return "" }
-                return "\(String(first).uppercased())\(token.dropFirst())"
-            }
-            .joined(separator: " ")
-        return titleCased.isEmpty ? nil : titleCased
-    }
-
-    private static func looksOpaqueIdentifier(_ value: String) -> Bool {
-        if value.count >= 24 {
-            let opaqueCharset = CharacterSet(charactersIn: "0123456789abcdefABCDEF-")
-            if value.unicodeScalars.allSatisfy({ opaqueCharset.contains($0) }) {
-                return true
-            }
-        }
-        if value.count > 64 {
-            return true
-        }
-        return false
-    }
-
-    private static func slugify(_ value: String) -> String {
-        let folded = value.folding(
-            options: [.diacriticInsensitive, .caseInsensitive, .widthInsensitive],
-            locale: .init(identifier: "en_US_POSIX"))
-        var scalarBuffer: [UnicodeScalar] = []
-        scalarBuffer.reserveCapacity(folded.unicodeScalars.count)
-
-        let allowed = CharacterSet.alphanumerics
-        var previousWasDash = false
-        for scalar in folded.unicodeScalars {
-            if allowed.contains(scalar) {
-                scalarBuffer.append(UnicodeScalar(String(scalar).lowercased()) ?? scalar)
-                previousWasDash = false
-            } else if !previousWasDash {
-                scalarBuffer.append("-")
-                previousWasDash = true
-            }
-        }
-
-        var slug = String(String.UnicodeScalarView(scalarBuffer))
-        while slug.hasPrefix("-") {
-            slug.removeFirst()
-        }
-        while slug.hasSuffix("-") {
-            slug.removeLast()
-        }
-        return slug
-    }
-
-    private static func firstPathLikeValue(candidates: [String?]) -> String? {
-        for candidate in candidates {
-            guard let candidate else { continue }
-            if candidate.contains("/") || candidate.contains("\\") {
-                return candidate
-            }
-        }
-        return nil
-    }
-
-    private static func stablePathHash(_ value: String) -> String {
-        let normalized = value.lowercased()
-        var hash: UInt64 = 0xCBF2_9CE4_8422_2325
-        for byte in normalized.utf8 {
-            hash ^= UInt64(byte)
-            hash = hash &* 0x100_0000_01B3
-        }
-        return String(format: "%016llx", hash)
-    }
-}

package/Sources/RunicCore/UsagePace.swift

@@ -1,81 +0,0 @@
-import Foundation
-
-public struct UsagePace: Sendable {
-    public enum Stage: Sendable {
-        case onTrack
-        case slightlyAhead
-        case ahead
-        case farAhead
-        case slightlyBehind
-        case behind
-        case farBehind
-    }
-
-    public let stage: Stage
-    public let deltaPercent: Double
-    public let expectedUsedPercent: Double
-    public let actualUsedPercent: Double
-    public let etaSeconds: TimeInterval?
-    public let willLastToReset: Bool
-
-    public static func weekly(
-        window: RateWindow,
-        now: Date = .init(),
-        defaultWindowMinutes: Int = 10080) -> UsagePace?
-    {
-        guard let resetsAt = window.resetsAt else { return nil }
-        let minutes = window.windowMinutes ?? defaultWindowMinutes
-        guard minutes > 0 else { return nil }
-
-        let duration = TimeInterval(minutes) * 60
-        let timeUntilReset = resetsAt.timeIntervalSince(now)
-        guard timeUntilReset > 0 else { return nil }
-        guard timeUntilReset <= duration else { return nil }
-        let elapsed = Self.clamp(duration - timeUntilReset, lower: 0, upper: duration)
-        let expected = Self.clamp((elapsed / duration) * 100, lower: 0, upper: 100)
-        let actual = Self.clamp(window.usedPercent, lower: 0, upper: 100)
-        if elapsed == 0, actual > 0 {
-            return nil
-        }
-        let delta = actual - expected
-        let stage = Self.stage(for: delta)
-
-        var etaSeconds: TimeInterval?
-        var willLastToReset = false
-
-        if elapsed > 0, actual > 0 {
-            let rate = actual / elapsed
-            if rate > 0 {
-                let remaining = max(0, 100 - actual)
-                let candidate = remaining / rate
-                if candidate >= timeUntilReset {
-                    willLastToReset = true
-                } else {
-                    etaSeconds = candidate
-                }
-            }
-        } else if elapsed > 0, actual == 0 {
-            willLastToReset = true
-        }
-
-        return UsagePace(
-            stage: stage,
-            deltaPercent: delta,
-            expectedUsedPercent: expected,
-            actualUsedPercent: actual,
-            etaSeconds: etaSeconds,
-            willLastToReset: willLastToReset)
-    }
-
-    private static func stage(for delta: Double) -> Stage {
-        let absDelta = abs(delta)
-        if absDelta <= 2 { return .onTrack }
-        if absDelta <= 6 { return delta >= 0 ? .slightlyAhead : .slightlyBehind }
-        if absDelta <= 12 { return delta >= 0 ? .ahead : .behind }
-        return delta >= 0 ? .farAhead : .farBehind
-    }
-
-    private static func clamp(_ value: Double, lower: Double, upper: Double) -> Double {
-        min(upper, max(lower, value))
-    }
-}

package/Sources/RunicCore/Vendored/CostUsage/CostUsageCache.swift

@@ -1,73 +0,0 @@
-import Foundation
-
-enum CostUsageCacheIO {
-    private static func defaultCacheRoot() -> URL {
-        let root = FileManager.default.urls(for: .cachesDirectory, in: .userDomainMask).first!
-        return root.appendingPathComponent("Runic", isDirectory: true)
-    }
-
-    static func cacheFileURL(provider: UsageProvider, cacheRoot: URL? = nil) -> URL {
-        let root = cacheRoot ?? self.defaultCacheRoot()
-        return root
-            .appendingPathComponent("cost-usage", isDirectory: true)
-            .appendingPathComponent("\(provider.rawValue)-v1.json", isDirectory: false)
-    }
-
-    static func load(provider: UsageProvider, cacheRoot: URL? = nil) -> CostUsageCache {
-        let url = self.cacheFileURL(provider: provider, cacheRoot: cacheRoot)
-        if let decoded = self.loadCache(at: url) { return decoded }
-        return CostUsageCache()
-    }
-
-    private static func loadCache(at url: URL) -> CostUsageCache? {
-        guard let data = try? Data(contentsOf: url) else { return nil }
-        guard let decoded = try? JSONDecoder().decode(CostUsageCache.self, from: data)
-        else { return nil }
-        guard decoded.version == 1 else { return nil }
-        return decoded
-    }
-
-    static func save(provider: UsageProvider, cache: CostUsageCache, cacheRoot: URL? = nil) {
-        let url = self.cacheFileURL(provider: provider, cacheRoot: cacheRoot)
-        let dir = url.deletingLastPathComponent()
-        try? FileManager.default.createDirectory(at: dir, withIntermediateDirectories: true)
-
-        let tmp = dir.appendingPathComponent(".tmp-\(UUID().uuidString).json", isDirectory: false)
-        let data = (try? JSONEncoder().encode(cache)) ?? Data()
-        do {
-            try data.write(to: tmp, options: [.atomic])
-            _ = try FileManager.default.replaceItemAt(url, withItemAt: tmp)
-        } catch {
-            try? FileManager.default.removeItem(at: tmp)
-        }
-    }
-}
-
-struct CostUsageCache: Codable {
-    var version: Int = 1
-    var lastScanUnixMs: Int64 = 0
-
-    /// filePath -> file usage
-    var files: [String: CostUsageFileUsage] = [:]
-
-    /// dayKey -> model -> packed usage
-    var days: [String: [String: [Int]]] = [:]
-
-    /// rootPath -> mtime (for Claude roots)
-    var roots: [String: Int64]?
-}
-
-struct CostUsageFileUsage: Codable {
-    var mtimeUnixMs: Int64
-    var size: Int64
-    var days: [String: [String: [Int]]]
-    var parsedBytes: Int64?
-    var lastModel: String?
-    var lastTotals: CostUsageCodexTotals?
-}
-
-struct CostUsageCodexTotals: Codable {
-    var input: Int
-    var cached: Int
-    var output: Int
-}

package/Sources/RunicCore/Vendored/CostUsage/CostUsageJsonl.swift

@@ -1,74 +0,0 @@
-import Foundation
-
-enum CostUsageJsonl {
-    struct Line {
-        let bytes: Data
-        let wasTruncated: Bool
-    }
-
-    @discardableResult
-    static func scan(
-        fileURL: URL,
-        offset: Int64 = 0,
-        maxLineBytes: Int,
-        prefixBytes: Int,
-        onLine: (Line) -> Void) throws
-        -> Int64
-    {
-        let handle = try FileHandle(forReadingFrom: fileURL)
-        defer { try? handle.close() }
-
-        let startOffset = max(0, offset)
-        if startOffset > 0 {
-            try handle.seek(toOffset: UInt64(startOffset))
-        }
-
-        var buffer = Data()
-        buffer.reserveCapacity(64 * 1024)
-
-        var current = Data()
-        current.reserveCapacity(4 * 1024)
-        var lineBytes = 0
-        var truncated = false
-        var bytesRead: Int64 = 0
-
-        func flushLine() {
-            guard lineBytes > 0 else { return }
-            let line = Line(bytes: current, wasTruncated: truncated)
-            onLine(line)
-            current.removeAll(keepingCapacity: true)
-            lineBytes = 0
-            truncated = false
-        }
-
-        while true {
-            let chunk = try handle.read(upToCount: 256 * 1024) ?? Data()
-            if chunk.isEmpty {
-                flushLine()
-                break
-            }
-
-            bytesRead += Int64(chunk.count)
-            buffer.append(chunk)
-
-            while true {
-                guard let nl = buffer.firstIndex(of: 0x0A) else { break }
-                let linePart = buffer[..<nl]
-                buffer.removeSubrange(...nl)
-
-                lineBytes += linePart.count
-                if !truncated {
-                    if lineBytes > maxLineBytes || lineBytes > prefixBytes {
-                        truncated = true
-                        current.removeAll(keepingCapacity: true)
-                    } else {
-                        current.append(contentsOf: linePart)
-                    }
-                }
-                flushLine()
-            }
-        }
-
-        return startOffset + bytesRead
-    }
-}