@sriinnu/runic 2.0.0 → 2.11.1

package/Sources/RunicCore/Host/Process/SubprocessRunner.swift

@@ -1,135 +0,0 @@
-#if canImport(Darwin)
-import Darwin
-#else
-import Glibc
-#endif
-import Foundation
-
-public enum SubprocessRunnerError: LocalizedError, Sendable {
-    case binaryNotFound(String)
-    case launchFailed(String)
-    case timedOut(String)
-    case nonZeroExit(code: Int32, stderr: String)
-
-    public var errorDescription: String? {
-        switch self {
-        case let .binaryNotFound(binary):
-            return "Missing CLI '\(binary)'. Install it and restart Runic."
-        case let .launchFailed(details):
-            return "Failed to launch process: \(details)"
-        case let .timedOut(label):
-            return "Command timed out: \(label)"
-        case let .nonZeroExit(code, stderr):
-            let trimmed = stderr.trimmingCharacters(in: .whitespacesAndNewlines)
-            if trimmed.isEmpty {
-                return "Command failed with exit code \(code)."
-            }
-            return "Command failed (\(code)): \(trimmed)"
-        }
-    }
-}
-
-public struct SubprocessResult: Sendable {
-    public let stdout: String
-    public let stderr: String
-}
-
-public enum SubprocessRunner {
-    public static func run(
-        binary: String,
-        arguments: [String],
-        environment: [String: String],
-        timeout: TimeInterval,
-        label: String) async throws -> SubprocessResult
-    {
-        guard FileManager.default.isExecutableFile(atPath: binary) else {
-            throw SubprocessRunnerError.binaryNotFound(binary)
-        }
-
-        let process = Process()
-        process.executableURL = URL(fileURLWithPath: binary)
-        process.arguments = arguments
-        process.environment = environment
-
-        let stdoutPipe = Pipe()
-        let stderrPipe = Pipe()
-        process.standardOutput = stdoutPipe
-        process.standardError = stderrPipe
-        process.standardInput = nil
-
-        let stdoutTask = Task<Data, Never> {
-            stdoutPipe.fileHandleForReading.readDataToEndOfFile()
-        }
-        let stderrTask = Task<Data, Never> {
-            stderrPipe.fileHandleForReading.readDataToEndOfFile()
-        }
-
-        do {
-            try process.run()
-        } catch {
-            stdoutTask.cancel()
-            stderrTask.cancel()
-            stdoutPipe.fileHandleForReading.closeFile()
-            stderrPipe.fileHandleForReading.closeFile()
-            throw SubprocessRunnerError.launchFailed(error.localizedDescription)
-        }
-
-        var processGroup: pid_t?
-        let pid = process.processIdentifier
-        if setpgid(pid, pid) == 0 {
-            processGroup = pid
-        }
-
-        let exitCodeTask = Task<Int32, Never> {
-            process.waitUntilExit()
-            return process.terminationStatus
-        }
-
-        do {
-            let exitCode = try await withThrowingTaskGroup(of: Int32.self) { group in
-                group.addTask { await exitCodeTask.value }
-                group.addTask {
-                    try await Task.sleep(for: .seconds(timeout))
-                    throw SubprocessRunnerError.timedOut(label)
-                }
-                let code = try await group.next()!
-                group.cancelAll()
-                return code
-            }
-
-            let stdoutData = await stdoutTask.value
-            let stderrData = await stderrTask.value
-            let stdout = String(data: stdoutData, encoding: .utf8) ?? ""
-            let stderr = String(data: stderrData, encoding: .utf8) ?? ""
-
-            if exitCode != 0 {
-                throw SubprocessRunnerError.nonZeroExit(code: exitCode, stderr: stderr)
-            }
-
-            return SubprocessResult(stdout: stdout, stderr: stderr)
-        } catch {
-            if process.isRunning {
-                process.terminate()
-                if let pgid = processGroup {
-                    kill(-pgid, SIGTERM)
-                }
-                let killDeadline = Date().addingTimeInterval(0.4)
-                while process.isRunning, Date() < killDeadline {
-                    usleep(50000)
-                }
-                if process.isRunning {
-                    if let pgid = processGroup {
-                        kill(-pgid, SIGKILL)
-                    }
-                    kill(process.processIdentifier, SIGKILL)
-                }
-            }
-            exitCodeTask.cancel()
-            stdoutTask.cancel()
-            stderrTask.cancel()
-            stdoutPipe.fileHandleForReading.closeFile()
-            stderrPipe.fileHandleForReading.closeFile()
-            throw error
-        }
-    }
-}

package/Sources/RunicCore/Integrations/GitHubIntegration.swift

@@ -1,173 +0,0 @@
-import Foundation
-
-public struct GitCommit: Codable, Sendable, Hashable {
-    public let sha: String
-    public let shortSha: String
-    public let message: String
-    public let author: String
-    public let timestamp: Date
-
-    public init(sha: String, shortSha: String, message: String, author: String, timestamp: Date) {
-        self.sha = sha
-        self.shortSha = shortSha
-        self.message = message
-        self.author = author
-        self.timestamp = timestamp
-    }
-}
-
-public struct UsageWithCommit: Codable, Sendable, Hashable {
-    public let entry: UsageLedgerEntry
-    public let commit: GitCommit?
-
-    public init(entry: UsageLedgerEntry, commit: GitCommit?) {
-        self.entry = entry
-        self.commit = commit
-    }
-}
-
-public enum GitHubIntegration {
-    private static let logger = RunicLog.logger("github-integration")
-    private static let commitMatchWindow: TimeInterval = 300 // 5 minutes
-
-    public static func linkCommitsToUsage(
-        entries: [UsageLedgerEntry],
-        gitDirectory: URL? = nil) -> [UsageWithCommit]
-    {
-        guard !entries.isEmpty else { return [] }
-
-        let gitDir = gitDirectory ?? self.defaultGitDirectory()
-        let commits = self.loadCommits(from: gitDir)
-
-        guard !commits.isEmpty else {
-            self.logger.debug("No git commits found, returning entries without commit info")
-            return entries.map { UsageWithCommit(entry: $0, commit: nil) }
-        }
-
-        self.logger.debug("Linking \(entries.count) usage entries with \(commits.count) commits")
-
-        return entries.map { entry in
-            let matchedCommit = self.findClosestCommit(for: entry, in: commits)
-            return UsageWithCommit(entry: entry, commit: matchedCommit)
-        }
-    }
-
-    private static func defaultGitDirectory() -> URL {
-        let fileManager = FileManager.default
-        let currentDirectory = fileManager.currentDirectoryPath
-        return URL(fileURLWithPath: currentDirectory).appendingPathComponent(".git")
-    }
-
-    private static func loadCommits(from gitDirectory: URL) -> [GitCommit] {
-        let headLogPath = gitDirectory.appendingPathComponent("logs/HEAD")
-        let fileManager = FileManager.default
-
-        guard fileManager.fileExists(atPath: headLogPath.path) else {
-            self.logger.warning("Git HEAD log not found at \(headLogPath.path)")
-            return []
-        }
-
-        guard let contents = try? String(contentsOf: headLogPath, encoding: .utf8) else {
-            self.logger.error("Failed to read git HEAD log at \(headLogPath.path)")
-            return []
-        }
-
-        let lines = contents.components(separatedBy: .newlines).filter { !$0.isEmpty }
-        var commits: [GitCommit] = []
-
-        for line in lines {
-            if let commit = parseCommitLine(line) {
-                commits.append(commit)
-            }
-        }
-
-        self.logger.debug("Parsed \(commits.count) commits from git log")
-        return commits
-    }
-
-    private static func parseCommitLine(_ line: String) -> GitCommit? {
-        // Format: old_sha new_sha Author Name <email> timestamp timezone\tcommit: message
-        // Example: 0000000000000000000000000000000000000000 538b8f7ef4110664c161b13326a2ebe65b6a1fb0 Sriinnu <hello@srinivas.dev> 1767822510 +0100\tcommit (initial): Add Runic sources
-
-        let parts = line.components(separatedBy: "\t")
-        guard parts.count >= 2 else {
-            self.logger.trace("Skipping malformed git log line (no tab separator)")
-            return nil
-        }
-
-        let headerPart = parts[0]
-        let messagePart = parts[1]
-
-        // Parse header: old_sha new_sha author timestamp timezone
-        let headerComponents = headerPart.components(separatedBy: " ")
-        guard headerComponents.count >= 5 else {
-            self.logger.trace("Skipping malformed git log header")
-            return nil
-        }
-
-        let newSha = headerComponents[1]
-        guard newSha != "0000000000000000000000000000000000000000" else {
-            self.logger.trace("Skipping null SHA")
-            return nil
-        }
-
-        // Extract timestamp (Unix epoch)
-        let timestampIndex = headerComponents.count - 2
-        guard let timestampValue = Double(headerComponents[timestampIndex]) else {
-            self.logger.trace("Failed to parse timestamp from git log")
-            return nil
-        }
-
-        let timestamp = Date(timeIntervalSince1970: timestampValue)
-
-        // Extract author (everything between sha and timestamp)
-        let authorEndIndex = timestampIndex
-        let authorComponents = Array(headerComponents[2..<authorEndIndex])
-        let author = authorComponents.joined(separator: " ")
-
-        // Extract message (remove "commit: " or "commit (initial): " prefix if present)
-        var message = messagePart
-        if message.hasPrefix("commit: ") {
-            message = String(message.dropFirst(8))
-        } else if message.hasPrefix("commit (initial): ") {
-            message = String(message.dropFirst(18))
-        } else if message.contains(": ") {
-            // Handle other prefixes like "pull", "merge", "rebase", etc.
-            if let colonIndex = message.firstIndex(of: ":") {
-                message = String(message[message.index(after: colonIndex)...]).trimmingCharacters(in: .whitespaces)
-            }
-        }
-
-        let shortSha = String(newSha.prefix(7))
-
-        return GitCommit(
-            sha: newSha,
-            shortSha: shortSha,
-            message: message,
-            author: author,
-            timestamp: timestamp)
-    }
-
-    private static func findClosestCommit(
-        for entry: UsageLedgerEntry,
-        in commits: [GitCommit]) -> GitCommit?
-    {
-        // Find commits within the 5-minute window
-        let entryTime = entry.timestamp
-        let matchingCommits = commits.filter { commit in
-            let timeDiff = abs(commit.timestamp.timeIntervalSince(entryTime))
-            return timeDiff <= self.commitMatchWindow
-        }
-
-        guard !matchingCommits.isEmpty else {
-            return nil
-        }
-
-        // Return the commit with the smallest time difference
-        return matchingCommits.min { commit1, commit2 in
-            let diff1 = abs(commit1.timestamp.timeIntervalSince(entryTime))
-            let diff2 = abs(commit2.timestamp.timeIntervalSince(entryTime))
-            return diff1 < diff2
-        }
-    }
-}

package/Sources/RunicCore/Logging/JSONStderrLogHandler.swift

@@ -1,79 +0,0 @@
-import Foundation
-import Logging
-#if canImport(Darwin)
-import Darwin
-#else
-import Glibc
-#endif
-
-struct JSONStderrLogHandler: LogHandler {
-    var metadata: Logger.Metadata = [:]
-    var logLevel: Logger.Level = .info
-
-    private let label: String
-    private let encoder: JSONEncoder
-
-    init(label: String) {
-        self.label = label
-        self.encoder = JSONEncoder()
-        self.encoder.dateEncodingStrategy = .iso8601
-        self.encoder.outputFormatting = [.sortedKeys]
-    }
-
-    subscript(metadataKey metadataKey: String) -> Logger.Metadata.Value? {
-        get { self.metadata[metadataKey] }
-        set { self.metadata[metadataKey] = newValue }
-    }
-
-    // swiftlint:disable:next function_parameter_count
-    func log(
-        level: Logger.Level,
-        message: Logger.Message,
-        metadata: Logger.Metadata?,
-        source: String,
-        file: String,
-        function: String,
-        line: UInt)
-    {
-        let ts = Date()
-        var combined = self.metadata
-        if let metadata { combined.merge(metadata, uniquingKeysWith: { _, new in new }) }
-
-        let payload = JSONLogLine(
-            timestamp: ts,
-            level: level.rawValue,
-            label: self.label,
-            message: message.description,
-            source: source,
-            file: file,
-            function: function,
-            line: line,
-            metadata: combined.isEmpty ? nil : combined.mapValues(\.description))
-
-        guard let data = try? self.encoder.encode(payload),
-              let text = String(data: data, encoding: .utf8) else { return }
-        Self.writeStderr(text + "\n")
-    }
-}
-
-private struct JSONLogLine: Encodable {
-    let timestamp: Date
-    let level: String
-    let label: String
-    let message: String
-    let source: String
-    let file: String
-    let function: String
-    let line: UInt
-    let metadata: [String: String]?
-}
-
-extension JSONStderrLogHandler {
-    private static func writeStderr(_ text: String) {
-        let bytes = Array(text.utf8)
-        bytes.withUnsafeBytes { buffer in
-            guard let baseAddress = buffer.baseAddress else { return }
-            _ = write(STDERR_FILENO, baseAddress, buffer.count)
-        }
-    }
-}

package/Sources/RunicCore/Logging/OSLogLogHandler.swift

@@ -1,86 +0,0 @@
-#if canImport(os)
-import Foundation
-import Logging
-import os
-
-struct OSLogLogHandler: LogHandler {
-    var metadata: Logging.Logger.Metadata = [:]
-    var logLevel: Logging.Logger.Level = .info
-
-    private let label: String
-    private let subsystem: String
-    private let logger: os.Logger
-
-    init(label: String, subsystem: String) {
-        self.label = label
-        self.subsystem = subsystem
-        let category = Self.category(from: label, subsystem: subsystem)
-        self.logger = os.Logger(subsystem: subsystem, category: category)
-    }
-
-    subscript(metadataKey metadataKey: String) -> Logging.Logger.Metadata.Value? {
-        get { self.metadata[metadataKey] }
-        set { self.metadata[metadataKey] = newValue }
-    }
-
-    // swiftlint:disable:next function_parameter_count
-    func log(
-        level: Logging.Logger.Level,
-        message: Logging.Logger.Message,
-        metadata: Logging.Logger.Metadata?,
-        source: String,
-        file: String,
-        function: String,
-        line: UInt)
-    {
-        let msg = Self.decorate(
-            message: message.description,
-            label: self.label,
-            subsystem: self.subsystem,
-            metadata: self.metadata,
-            extraMetadata: metadata)
-
-        switch level {
-        case .trace:
-            self.logger.debug("\(msg, privacy: .auto)")
-        case .debug:
-            self.logger.debug("\(msg, privacy: .auto)")
-        case .info, .notice:
-            self.logger.info("\(msg, privacy: .auto)")
-        case .warning:
-            self.logger.warning("\(msg, privacy: .auto)")
-        case .error:
-            self.logger.error("\(msg, privacy: .auto)")
-        case .critical:
-            self.logger.fault("\(msg, privacy: .auto)")
-        }
-    }
-
-    private static func category(from label: String, subsystem: String) -> String {
-        let prefix = subsystem + "."
-        guard label.hasPrefix(prefix) else { return label }
-        return String(label.dropFirst(prefix.count))
-    }
-
-    private static func decorate(
-        message: String,
-        label: String,
-        subsystem: String,
-        metadata: Logging.Logger.Metadata,
-        extraMetadata: Logging.Logger.Metadata?)
-        -> String
-    {
-        var merged = metadata
-        if let extraMetadata { merged.merge(extraMetadata, uniquingKeysWith: { _, new in new }) }
-        guard !merged.isEmpty else { return message }
-
-        let suffix = merged
-            .sorted(by: { $0.key < $1.key })
-            .map { "\($0.key)=\($0.value)" }
-            .joined(separator: " ")
-        _ = label
-        _ = subsystem
-        return "\(message) (\(suffix))"
-    }
-}
-#endif

package/Sources/RunicCore/Logging/RunicLog.swift

@@ -1,123 +0,0 @@
-import Foundation
-import Logging
-
-public enum RunicLog {
-    public enum Destination: Sendable {
-        case stderr
-        case oslog(subsystem: String)
-    }
-
-    public enum Level: String, Sendable {
-        case trace
-        case verbose
-        case debug
-        case info
-        case warning
-        case error
-        case critical
-
-        public var asSwiftLogLevel: Logger.Level {
-            switch self {
-            case .trace: .trace
-            case .verbose: .debug
-            case .debug: .debug
-            case .info: .info
-            case .warning: .warning
-            case .error: .error
-            case .critical: .critical
-            }
-        }
-    }
-
-    public struct Configuration: Sendable {
-        public let destination: Destination
-        public let level: Level
-        public let json: Bool
-
-        public init(destination: Destination, level: Level, json: Bool) {
-            self.destination = destination
-            self.level = level
-            self.json = json
-        }
-    }
-
-    private static let lock = NSLock()
-    private nonisolated(unsafe) static var isBootstrapped = false
-
-    public static func bootstrapIfNeeded(_ config: Configuration) {
-        self.lock.lock()
-        defer { lock.unlock() }
-        guard !self.isBootstrapped else { return }
-
-        let baseFactory: @Sendable (String) -> any LogHandler = { label in
-            switch config.destination {
-            case .stderr:
-                if config.json { return JSONStderrLogHandler(label: label) }
-                return StreamLogHandler.standardError(label: label)
-            case let .oslog(subsystem):
-                #if canImport(os)
-                return OSLogLogHandler(label: label, subsystem: subsystem)
-                #else
-                if config.json { return JSONStderrLogHandler(label: label) }
-                return StreamLogHandler.standardError(label: label)
-                #endif
-            }
-        }
-
-        LoggingSystem.bootstrap { label in
-            var handler = baseFactory(label)
-            handler.logLevel = config.level.asSwiftLogLevel
-            return handler
-        }
-
-        self.isBootstrapped = true
-    }
-
-    public static func logger(_ category: String) -> RunicLogger {
-        let logger = Logger(label: "com.sriinnu.athena.runic.\(category)")
-        return RunicLogger { level, message, metadata in
-            let swiftLogLevel = level.asSwiftLogLevel
-            let meta = metadata?.reduce(into: Logger.Metadata()) { partial, entry in
-                partial[entry.key] = .string(entry.value)
-            }
-            logger.log(level: swiftLogLevel, "\(message)", metadata: meta)
-        }
-    }
-
-    public static func parseLevel(_ raw: String?) -> Level? {
-        guard let raw, !raw.isEmpty else { return nil }
-        return Level(rawValue: raw.trimmingCharacters(in: .whitespacesAndNewlines).lowercased())
-    }
-}
-
-public struct RunicLogger: Sendable {
-    private let logFn: @Sendable (RunicLog.Level, String, [String: String]?) -> Void
-
-    fileprivate init(_ logFn: @escaping @Sendable (RunicLog.Level, String, [String: String]?) -> Void) {
-        self.logFn = logFn
-    }
-
-    public func trace(_ message: @autoclosure () -> String, metadata: [String: String]? = nil) {
-        self.logFn(.trace, message(), metadata)
-    }
-
-    public func debug(_ message: @autoclosure () -> String, metadata: [String: String]? = nil) {
-        self.logFn(.debug, message(), metadata)
-    }
-
-    public func info(_ message: @autoclosure () -> String, metadata: [String: String]? = nil) {
-        self.logFn(.info, message(), metadata)
-    }
-
-    public func warning(_ message: @autoclosure () -> String, metadata: [String: String]? = nil) {
-        self.logFn(.warning, message(), metadata)
-    }
-
-    public func error(_ message: @autoclosure () -> String, metadata: [String: String]? = nil) {
-        self.logFn(.error, message(), metadata)
-    }
-
-    public func critical(_ message: @autoclosure () -> String, metadata: [String: String]? = nil) {
-        self.logFn(.critical, message(), metadata)
-    }
-}