@hasna/recordings 0.1.10 → 0.1.12

package/src/native/Recordings/RecordingsLib/NativePCMRecorder.swift

@@ -0,0 +1,164 @@
+@preconcurrency import AVFoundation
+import Foundation
+
+enum NativePCMRecorderError: LocalizedError {
+    case noInputDevice
+    case unsupportedInputFormat
+    case failedToCreateConverter
+    case failedToStart(String)
+
+    var errorDescription: String? {
+        switch self {
+        case .noInputDevice:
+            return "No microphone input device is available"
+        case .unsupportedInputFormat:
+            return "The selected microphone format is not supported"
+        case .failedToCreateConverter:
+            return "Could not prepare microphone audio conversion"
+        case .failedToStart(let message):
+            return "Could not start microphone capture: \(message)"
+        }
+    }
+}
+
+final class NativePCMRecorder: @unchecked Sendable {
+    private let engine = AVAudioEngine()
+    private let onPCM: @Sendable (Data) -> Void
+    private var converter: AVAudioConverter?
+    private var inputFormat: AVAudioFormat?
+    private var outputFormat: AVAudioFormat?
+    private var started = false
+
+    init(onPCM: @escaping @Sendable (Data) -> Void) {
+        self.onPCM = onPCM
+    }
+
+    func start() throws {
+        guard !started else { return }
+
+        let inputNode = engine.inputNode
+        let inputFormat = inputNode.inputFormat(forBus: 0)
+        guard inputFormat.channelCount > 0 else {
+            throw NativePCMRecorderError.noInputDevice
+        }
+        guard inputFormat.sampleRate > 0 else {
+            throw NativePCMRecorderError.unsupportedInputFormat
+        }
+        guard let outputFormat = Self.realtimeOutputFormat() else {
+            throw NativePCMRecorderError.unsupportedInputFormat
+        }
+        guard let converter = AVAudioConverter(from: inputFormat, to: outputFormat) else {
+            throw NativePCMRecorderError.failedToCreateConverter
+        }
+
+        self.converter = converter
+        self.inputFormat = inputFormat
+        self.outputFormat = outputFormat
+
+        inputNode.installTap(onBus: 0, bufferSize: 1_024, format: inputFormat) { [weak self] buffer, _ in
+            self?.convertAndEmit(buffer)
+        }
+
+        do {
+            engine.prepare()
+            try engine.start()
+            started = true
+        } catch {
+            inputNode.removeTap(onBus: 0)
+            self.converter = nil
+            self.inputFormat = nil
+            self.outputFormat = nil
+            throw NativePCMRecorderError.failedToStart(error.localizedDescription)
+        }
+    }
+
+    func stop() {
+        guard started else {
+            converter = nil
+            inputFormat = nil
+            outputFormat = nil
+            return
+        }
+
+        engine.inputNode.removeTap(onBus: 0)
+        engine.stop()
+        converter = nil
+        inputFormat = nil
+        outputFormat = nil
+        started = false
+    }
+
+    deinit {
+        stop()
+    }
+
+    private func convertAndEmit(_ inputBuffer: AVAudioPCMBuffer) {
+        guard let converter, let inputFormat, let outputFormat else { return }
+
+        let sampleRateRatio = outputFormat.sampleRate / inputFormat.sampleRate
+        let estimatedFrames = AVAudioFrameCount(Double(inputBuffer.frameLength) * sampleRateRatio) + 512
+        guard let outputBuffer = AVAudioPCMBuffer(
+            pcmFormat: outputFormat,
+            frameCapacity: max(estimatedFrames, 1)
+        ) else {
+            return
+        }
+
+        let inputSource = AudioConverterInputSource(buffer: inputBuffer)
+        var conversionError: NSError?
+        converter.convert(to: outputBuffer, error: &conversionError) { _, status in
+            inputSource.next(status: status)
+        }
+
+        guard conversionError == nil else { return }
+        let data = Self.extractPCM16Data(from: outputBuffer)
+        if !data.isEmpty {
+            onPCM(data)
+        }
+    }
+
+    static func realtimeOutputFormat() -> AVAudioFormat? {
+        AVAudioFormat(
+            commonFormat: .pcmFormatInt16,
+            sampleRate: 24_000,
+            channels: 1,
+            interleaved: true
+        )
+    }
+
+    static func extractPCM16Data(from buffer: AVAudioPCMBuffer) -> Data {
+        var data = Data()
+        for audioBuffer in UnsafeMutableAudioBufferListPointer(buffer.mutableAudioBufferList) {
+            guard let bytes = audioBuffer.mData?.assumingMemoryBound(to: UInt8.self),
+                  audioBuffer.mDataByteSize > 0 else {
+                continue
+            }
+            data.append(bytes, count: Int(audioBuffer.mDataByteSize))
+        }
+        return data
+    }
+}
+
+private final class AudioConverterInputSource: @unchecked Sendable {
+    private let buffer: AVAudioPCMBuffer
+    private let lock = NSLock()
+    private var consumed = false
+
+    init(buffer: AVAudioPCMBuffer) {
+        self.buffer = buffer
+    }
+
+    func next(status: UnsafeMutablePointer<AVAudioConverterInputStatus>) -> AVAudioBuffer? {
+        lock.lock()
+        defer { lock.unlock() }
+
+        if consumed {
+            status.pointee = .noDataNow
+            return nil
+        }
+
+        consumed = true
+        status.pointee = .haveData
+        return buffer
+    }
+}

package/src/native/Recordings/RecordingsLib/OpenAIAPIKeyStore.swift

@@ -0,0 +1,113 @@
+import Foundation
+
+enum OpenAIAPIKeyStore {
+    static func load(
+        homePath: String,
+        environment: [String: String] = ProcessInfo.processInfo.environment,
+        userDefaultKey: String? = UserDefaults.standard.string(forKey: "openAIAPIKey")
+    ) -> String {
+        if let key = firstNonEmpty(environment["OPENAI_API_KEY"], environment["RECORDINGS_API_KEY"]) {
+            return key
+        }
+        if let key = firstNonEmpty(userDefaultKey) {
+            return key
+        }
+        if let key = loadConfigKey(homePath: homePath, environment: environment) {
+            return key
+        }
+        if let key = loadSecretKey(homePath: homePath) {
+            return key
+        }
+        return ""
+    }
+
+    private static func loadConfigKey(homePath: String, environment: [String: String]) -> String? {
+        let url = URL(fileURLWithPath: homePath)
+            .appendingPathComponent(".hasna")
+            .appendingPathComponent("recordings")
+            .appendingPathComponent("config.json")
+
+        guard let data = try? Data(contentsOf: url),
+              let json = try? JSONSerialization.jsonObject(with: data) as? [String: Any]
+        else { return nil }
+
+        for key in ["openai_api_key", "api_key"] {
+            guard let value = json[key] as? String,
+                  let resolved = resolve(value: value, environment: environment)
+            else { continue }
+            return resolved
+        }
+        return nil
+    }
+
+    private static func loadSecretKey(homePath: String) -> String? {
+        let root = URL(fileURLWithPath: homePath).appendingPathComponent(".secrets")
+        let fileManager = FileManager.default
+        guard let enumerator = fileManager.enumerator(
+            at: root,
+            includingPropertiesForKeys: [.isRegularFileKey],
+            options: [.skipsHiddenFiles]
+        ) else { return nil }
+
+        for case let url as URL in enumerator {
+            guard url.pathExtension == "env",
+                  let values = try? parseEnvFile(url: url)
+            else { continue }
+
+            if let key = firstNonEmpty(values["RECORDINGS_API_KEY"], values["OPENAI_API_KEY"]) {
+                return key
+            }
+        }
+        return nil
+    }
+
+    private static func parseEnvFile(url: URL) throws -> [String: String] {
+        let content = try String(contentsOf: url, encoding: .utf8)
+        var values: [String: String] = [:]
+
+        for rawLine in content.split(whereSeparator: \.isNewline) {
+            var line = rawLine.trimmingCharacters(in: .whitespacesAndNewlines)
+            guard !line.isEmpty, !line.hasPrefix("#") else { continue }
+            if line.hasPrefix("export ") {
+                line.removeFirst("export ".count)
+            }
+
+            let parts = line.split(separator: "=", maxSplits: 1, omittingEmptySubsequences: false)
+            guard parts.count == 2 else { continue }
+
+            let key = parts[0].trimmingCharacters(in: .whitespacesAndNewlines)
+            let value = stripQuotes(String(parts[1]).trimmingCharacters(in: .whitespacesAndNewlines))
+            values[key] = value
+        }
+
+        return values
+    }
+
+    private static func resolve(value: String, environment: [String: String]) -> String? {
+        let trimmed = value.trimmingCharacters(in: .whitespacesAndNewlines)
+        guard !trimmed.isEmpty else { return nil }
+        if trimmed.hasPrefix("$"), trimmed.count > 1 {
+            return firstNonEmpty(environment[String(trimmed.dropFirst())])
+        }
+        return trimmed
+    }
+
+    private static func stripQuotes(_ value: String) -> String {
+        guard value.count >= 2 else { return value }
+        if (value.hasPrefix("\"") && value.hasSuffix("\"")) ||
+            (value.hasPrefix("'") && value.hasSuffix("'")) {
+            return String(value.dropFirst().dropLast())
+        }
+        return value
+    }
+
+    private static func firstNonEmpty(_ values: String?...) -> String? {
+        for value in values {
+            let trimmed = value?.trimmingCharacters(in: .whitespacesAndNewlines) ?? ""
+            if !trimmed.isEmpty {
+                return trimmed
+            }
+        }
+        return nil
+    }
+}

package/src/native/Recordings/RecordingsLib/ProjectStore.swift

@@ -0,0 +1,126 @@
+import Foundation
+
+public struct RecProject: Codable, Identifiable, Sendable {
+    public let id: String
+    public var name: String
+    var path: String?
+    var systemPrompt: String?
+    var appBundleIds: [String]?
+
+    public init(name: String, path: String? = nil, systemPrompt: String? = nil, appBundleIds: [String]? = nil) {
+        self.id = UUID().uuidString
+        self.name = name
+        self.path = path
+        self.systemPrompt = systemPrompt
+        self.appBundleIds = appBundleIds
+    }
+}
+
+public struct ProjectSettings: Codable, Sendable {
+    var globalSystemPrompt: String
+    var projects: [RecProject]
+    var activeProjectId: String?
+
+    public init() {
+        globalSystemPrompt = ""
+        projects = []
+        activeProjectId = nil
+    }
+}
+
+@MainActor
+public final class ProjectStore: ObservableObject {
+    @Published public var settings = ProjectSettings()
+
+    private let filePath: String
+
+    public var activeProject: RecProject? {
+        settings.projects.first { $0.id == settings.activeProjectId }
+    }
+
+    public var effectiveSystemPrompt: String {
+        let global = settings.globalSystemPrompt.trimmingCharacters(in: .whitespacesAndNewlines)
+        let project = activeProject?.systemPrompt?.trimmingCharacters(in: .whitespacesAndNewlines) ?? ""
+        if global.isEmpty && project.isEmpty { return "" }
+        if global.isEmpty { return project }
+        if project.isEmpty { return global }
+        return "\(global)\n\n\(project)"
+    }
+
+    public init() {
+        let home = FileManager.default.homeDirectoryForCurrentUser.path
+        filePath = "\(home)/.hasna/recordings/projects.json"
+        load()
+    }
+
+    func load() {
+        guard FileManager.default.fileExists(atPath: filePath),
+              let data = FileManager.default.contents(atPath: filePath) else { return }
+        do {
+            settings = try JSONDecoder().decode(ProjectSettings.self, from: data)
+        } catch {
+            fputs("[ProjectStore] Failed to load: \(error)\n", stderr)
+        }
+    }
+
+    func save() {
+        do {
+            let data = try JSONEncoder().encode(settings)
+            let dir = (filePath as NSString).deletingLastPathComponent
+            try FileManager.default.createDirectory(atPath: dir, withIntermediateDirectories: true)
+            try data.write(to: URL(fileURLWithPath: filePath))
+        } catch {
+            fputs("[ProjectStore] Failed to save: \(error)\n", stderr)
+        }
+    }
+
+    func addProject(name: String, path: String? = nil, systemPrompt: String? = nil) {
+        let project = RecProject(name: name, path: path, systemPrompt: systemPrompt)
+        settings.projects.append(project)
+        save()
+    }
+
+    func updateProject(_ project: RecProject) {
+        guard let idx = settings.projects.firstIndex(where: { $0.id == project.id }) else { return }
+        settings.projects[idx] = project
+        save()
+    }
+
+    func removeProject(id: String) {
+        settings.projects.removeAll { $0.id == id }
+        if settings.activeProjectId == id { settings.activeProjectId = nil }
+        save()
+    }
+
+    func setActive(_ id: String?) {
+        settings.activeProjectId = id
+        save()
+    }
+
+    // MARK: - Auto-detection
+
+    nonisolated static func matchProject(windowTitle: String?, bundleId: String?, projects: [RecProject]) -> RecProject? {
+        if let bundleId {
+            if let match = projects.first(where: { $0.appBundleIds?.contains(bundleId) == true }) {
+                return match
+            }
+        }
+
+        if let title = windowTitle {
+            let lower = title.lowercased()
+            for project in projects {
+                let name = project.name.lowercased()
+                if lower.contains(name) { return project }
+                let slug = name.replacingOccurrences(of: " ", with: "-")
+                if lower.contains(slug) { return project }
+                if let path = project.path {
+                    let dirName = (path as NSString).lastPathComponent.lowercased()
+                    if lower.contains(dirName) { return project }
+                }
+            }
+        }
+
+        return nil
+    }
+
+}