@sriinnu/runic 1.0.0

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

@@ -0,0 +1,135 @@
+#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

@@ -0,0 +1,173 @@
+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 ?? defaultGitDirectory()
+        let commits = 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 = 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

@@ -0,0 +1,79 @@
+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

@@ -0,0 +1,86 @@
+#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: .public)")
+        case .debug:
+            self.logger.debug("\(msg, privacy: .public)")
+        case .info, .notice:
+            self.logger.info("\(msg, privacy: .public)")
+        case .warning:
+            self.logger.warning("\(msg, privacy: .public)")
+        case .error:
+            self.logger.error("\(msg, privacy: .public)")
+        case .critical:
+            self.logger.fault("\(msg, privacy: .public)")
+        }
+    }
+
+    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

@@ -0,0 +1,123 @@
+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)
+    }
+}