@hasna/recordings 0.1.10 → 0.1.11

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

@@ -0,0 +1,126 @@
+import Foundation
+
+struct RecProject: Codable, Identifiable, Sendable {
+    let id: String
+    var name: String
+    var path: String?
+    var systemPrompt: String?
+    var appBundleIds: [String]?
+
+    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
+    }
+}
+
+struct ProjectSettings: Codable, Sendable {
+    var globalSystemPrompt: String
+    var projects: [RecProject]
+    var activeProjectId: String?
+
+    init() {
+        globalSystemPrompt = ""
+        projects = []
+        activeProjectId = nil
+    }
+}
+
+@MainActor
+final class ProjectStore: ObservableObject {
+    @Published var settings = ProjectSettings()
+
+    private let filePath: String
+
+    var activeProject: RecProject? {
+        settings.projects.first { $0.id == settings.activeProjectId }
+    }
+
+    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)"
+    }
+
+    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
+    }
+
+}

package/src/native/Recordings/Recordings/RecordingEngine.swift

@@ -4,7 +4,7 @@ import KeyboardShortcuts
 // MARK: - Custom shortcut (not fn — fn is handled by FnKeyMonitor)
 
 extension KeyboardShortcuts.Name {
-    static let toggleRecording = Self("toggleRecording")
+    static let toggleRecording = Self("toggleRecording", default: .init(.f5))
 }
 
 // MARK: - Recording Mode
@@ -24,9 +24,9 @@ enum RecordingMode: String, CaseIterable, Identifiable, Sendable {
     }
     var hint: String {
         switch self {
-        case .pushToTalk: return "Hold fn to record, release to stop & paste"
-        case .dictation: return "Hold fn to dictate, release to stop & paste"
-        case .command: return "Select text, hold fn, speak to rewrite"
+        case .pushToTalk: return "Hold F5 or your chosen shortcut to record, then release to paste"
+        case .dictation: return "Hold F5 or your chosen shortcut to dictate, then release to paste"
+        case .command: return "Select text, then hold F5 or your chosen shortcut and release to rewrite"
         }
     }
 }
@@ -37,16 +37,24 @@ struct TranscriptionResult: Sendable {
     let rawText: String
     let processedText: String?
     let timestamp: Date
+    let projectId: String?
+    let projectName: String?
     var displayText: String { processedText ?? rawText }
 }
 
+enum RecordingTrigger {
+    case manual
+    case fnKey
+    case keyboardShortcut
+}
+
 // MARK: - Recording Engine
 
 @MainActor
 final class RecordingEngine: ObservableObject {
     @Published var isRecording = false
     @Published var mode: RecordingMode = .pushToTalk
-    @Published var useFnKey: Bool = true {
+    @Published var useFnKey: Bool = false {
         didSet {
             UserDefaults.standard.set(useFnKey, forKey: "useFnKey")
             updateFnMonitor()
@@ -63,7 +71,12 @@ final class RecordingEngine: ObservableObject {
     private var stdinPipe: Pipe?
     private var currentAudioPath: String?
     private var recordingTimer: Timer?
+    private var activeTrigger: RecordingTrigger?
+    private var keyboardShortcutIsDown = false
+    private var targetAppBundleIdentifier: String?
+    private var targetAppPid: pid_t?
     private let maxDuration = 300
+    var projectStore: ProjectStore?
 
     // fn key monitor (CGEventTap-based, swallows fn to prevent emoji picker)
     private let fnMonitor = FnKeyMonitor()
@@ -75,27 +88,40 @@ final class RecordingEngine: ObservableObject {
         try? FileManager.default.createDirectory(atPath: audioDir, withIntermediateDirectories: true)
 
         // Load preferences
-        useFnKey = UserDefaults.standard.object(forKey: "useFnKey") as? Bool ?? true
+        useFnKey = UserDefaults.standard.object(forKey: "useFnKey") as? Bool ?? false
+        if KeyboardShortcuts.getShortcut(for: .toggleRecording) == nil {
+            KeyboardShortcuts.setShortcut(.init(.f5), for: .toggleRecording)
+        }
 
         // Set up fn key monitor — hold fn to record, release to stop (like WisprFlow)
         fnMonitor.onFnKeyDown = { [weak self] in
             Task { @MainActor [weak self] in
                 guard let self, self.useFnKey, !self.isRecording else { return }
-                self.startRecording()
+                self.startRecording(trigger: .fnKey)
             }
         }
         fnMonitor.onFnKeyUp = { [weak self] in
             Task { @MainActor [weak self] in
-                guard let self, self.useFnKey, self.isRecording else { return }
+                guard let self, self.useFnKey, self.isRecording, self.activeTrigger == .fnKey else { return }
                 self.stopAndTranscribe()
             }
         }
         updateFnMonitor()
 
-        // Set up custom shortcut (toggle mode — press to start, press to stop)
+        KeyboardShortcuts.onKeyDown(for: .toggleRecording) { [weak self] in
+            Task { @MainActor [weak self] in
+                guard let self, !self.keyboardShortcutIsDown else { return }
+                self.keyboardShortcutIsDown = true
+                guard !self.isRecording else { return }
+                self.startRecording(trigger: .keyboardShortcut)
+            }
+        }
         KeyboardShortcuts.onKeyUp(for: .toggleRecording) { [weak self] in
             Task { @MainActor [weak self] in
-                self?.toggleRecording()
+                guard let self, self.keyboardShortcutIsDown else { return }
+                self.keyboardShortcutIsDown = false
+                guard self.isRecording, self.activeTrigger == .keyboardShortcut else { return }
+                self.stopAndTranscribe()
             }
         }
 
@@ -106,7 +132,7 @@ final class RecordingEngine: ObservableObject {
         if useFnKey {
             let ok = fnMonitor.start()
             if !ok {
-                statusMessage = "fn needs Accessibility permission (System Settings > Privacy & Security > Accessibility)"
+                statusMessage = "fn needs Input Monitoring / Accessibility permission, and Globe must be set to Do Nothing"
             }
         } else {
             fnMonitor.stop()
@@ -115,32 +141,36 @@ final class RecordingEngine: ObservableObject {
 
     func updateStatus() {
         if isRecording || isTranscribing { return }
-
-        var parts: [String] = []
-        if useFnKey {
-            parts.append("fn (hold)")
-        }
-        if let shortcut = KeyboardShortcuts.getShortcut(for: .toggleRecording) {
-            parts.append(shortcut.description)
-        }
-
-        if parts.isEmpty {
-            statusMessage = "No shortcut set — enable fn or set a custom shortcut"
-        } else {
-            statusMessage = "Ready — press \(parts.joined(separator: " or ")) to record"
-        }
+        statusMessage = "Ready"
     }
 
     // MARK: - Toggle
 
     func toggleRecording() {
-        if isRecording { stopAndTranscribe() } else { startRecording() }
+        if isRecording { stopAndTranscribe() } else { startRecording(trigger: .manual) }
     }
 
     // MARK: - Start Recording
 
-    func startRecording() {
+    func startRecording(trigger: RecordingTrigger = .manual) {
         guard !isRecording else { return }
+        activeTrigger = trigger
+        keyboardShortcutIsDown = trigger == .keyboardShortcut
+
+        let myPID = ProcessInfo.processInfo.processIdentifier
+        let frontmostApp = NSWorkspace.shared.frontmostApplication
+        let isOwnApp = frontmostApp?.processIdentifier == myPID
+        targetAppBundleIdentifier = isOwnApp ? nil : frontmostApp?.bundleIdentifier
+        targetAppPid = isOwnApp ? nil : frontmostApp?.processIdentifier
+
+        if let store = projectStore {
+            let windowTitle = Self.focusedWindowTitle(pid: frontmostApp?.processIdentifier)
+            let projects = store.settings.projects
+            let detected = ProjectStore.matchProject(windowTitle: windowTitle, bundleId: targetAppBundleIdentifier, projects: projects)
+            if let detected {
+                store.setActive(detected.id)
+            }
+        }
 
         let ts = DateFormatter()
         ts.dateFormat = "yyyyMMdd'T'HHmmss"
@@ -149,11 +179,12 @@ final class RecordingEngine: ObservableObject {
 
         let proc = Process()
         let stdin = Pipe()
+        let stderrPipe = Pipe()
         proc.executableURL = URL(fileURLWithPath: "/bin/bash")
         proc.arguments = ["-c", """
             export PATH="/opt/homebrew/bin:/usr/local/bin:$PATH"
             if command -v ffmpeg &>/dev/null; then
-                ffmpeg -f avfoundation -i ":0" -ar 16000 -ac 1 -t \(maxDuration) "\(path)" -y 2>/dev/null
+                ffmpeg -f avfoundation -i ":0" -ar 16000 -ac 1 -t \(maxDuration) "\(path)" -y
             elif command -v rec &>/dev/null; then
                 rec -r 16000 -c 1 -b 16 "\(path)" trim 0 \(maxDuration)
             else
@@ -162,7 +193,7 @@ final class RecordingEngine: ObservableObject {
         """]
         proc.standardInput = stdin
         proc.standardOutput = FileHandle.nullDevice
-        proc.standardError = FileHandle.nullDevice
+        proc.standardError = stderrPipe
 
         do {
             try proc.run()
@@ -170,7 +201,11 @@ final class RecordingEngine: ObservableObject {
             stdinPipe = stdin
             isRecording = true
             recordingDuration = 0
-            statusMessage = mode == .command ? "Speak your instruction..." : "Recording — press fn to stop"
+            statusMessage = switch (mode, trigger) {
+            case (.command, _): "Speak your instruction..."
+            case (_, .manual): "Recording — click Stop when finished"
+            case (_, .fnKey), (_, .keyboardShortcut): "Recording — release to stop"
+            }
 
             recordingTimer = Timer.scheduledTimer(withTimeInterval: 0.1, repeats: true) { [weak self] _ in
                 Task { @MainActor [weak self] in
@@ -178,6 +213,9 @@ final class RecordingEngine: ObservableObject {
                 }
             }
         } catch {
+            activeTrigger = nil
+            keyboardShortcutIsDown = false
+            targetAppBundleIdentifier = nil
             statusMessage = "Failed: \(error.localizedDescription)"
         }
     }
@@ -204,6 +242,14 @@ final class RecordingEngine: ObservableObject {
         currentAudioPath = nil
         recordProcess = nil
         stdinPipe = nil
+        let targetAppBundleIdentifier = targetAppBundleIdentifier
+        let systemPrompt = projectStore?.effectiveSystemPrompt ?? ""
+        let activeProjectId = projectStore?.settings.activeProjectId
+        let activeProjectName = projectStore?.activeProject?.name
+        activeTrigger = nil
+        keyboardShortcutIsDown = false
+        self.targetAppBundleIdentifier = nil
+        self.targetAppPid = nil
         let homePath = home
 
         Task.detached {
@@ -212,6 +258,12 @@ final class RecordingEngine: ObservableObject {
             try? await Task.sleep(for: .milliseconds(300))
             if proc.isRunning { proc.interrupt() }
 
+            // Check if ffmpeg exited with an error (e.g. no mic permission)
+            if proc.terminationStatus != 0, proc.terminationStatus != 1 {
+                await MainActor.run { self.finish("Recording failed (mic access denied — check System Settings > Privacy & Security > Microphone)") }
+                return
+            }
+
             guard let audioPath else {
                 await MainActor.run { self.finish("No audio file") }
                 return
@@ -220,13 +272,21 @@ final class RecordingEngine: ObservableObject {
             let attrs = try? FileManager.default.attributesOfItem(atPath: audioPath)
             let size = (attrs?[.size] as? Int) ?? 0
             guard size >= 1000 else {
-                await MainActor.run { self.finish("Audio too short — speak longer") }
+                await MainActor.run { self.finish("No audio captured — check microphone permissions") }
                 return
             }
 
-            let output = CLIRunner.run(["transcribe", audioPath, "--json"], home: homePath)
-            let text = CLIRunner.parseJSON(output)
+            var cliArgs = ["transcribe", audioPath, "--json"]
+            if !systemPrompt.isEmpty {
+                cliArgs += ["--system-prompt", systemPrompt]
+            }
+            let output = CLIRunner.run(cliArgs, home: homePath)
+            if let error = CLIRunner.parseError(output) {
+                await MainActor.run { self.finish(error) }
+                return
+            }
 
+            let text = CLIRunner.parseJSON(output)
             guard let text, !text.isEmpty else {
                 await MainActor.run { self.finish("Empty transcription") }
                 return
@@ -237,12 +297,12 @@ final class RecordingEngine: ObservableObject {
                 if curMode == .command {
                     self.runCommandMode(instruction: text)
                 } else {
-                    self.pasteIntoFrontApp(text)
+                    self.pasteIntoFrontApp(text, targetAppBundleIdentifier: targetAppBundleIdentifier)
                     self.recentTranscriptions.insert(
-                        TranscriptionResult(rawText: text, processedText: nil, timestamp: Date()), at: 0
+                        TranscriptionResult(rawText: text, processedText: nil, timestamp: Date(), projectId: activeProjectId, projectName: activeProjectName), at: 0
                     )
                     if self.recentTranscriptions.count > 20 { self.recentTranscriptions.removeLast() }
-                    self.statusMessage = "Pasted: \(String(text.prefix(50)))"
+                    // statusMessage updated by pasteIntoFrontApp
                 }
             }
         }
@@ -250,7 +310,7 @@ final class RecordingEngine: ObservableObject {
 
     private func finish(_ msg: String) {
         isTranscribing = false
-        statusMessage = msg
+        updateStatus()
     }
 
     // MARK: - Command Mode
@@ -285,35 +345,53 @@ final class RecordingEngine: ObservableObject {
         }
     }
 
+    // MARK: - Window Title (Accessibility API)
+
+    private static func focusedWindowTitle(pid: pid_t?) -> String? {
+        guard let pid else { return nil }
+        let app = AXUIElementCreateApplication(pid)
+        var windowRef: CFTypeRef?
+        guard AXUIElementCopyAttributeValue(app, kAXFocusedWindowAttribute as CFString, &windowRef) == .success,
+              let window = windowRef else { return nil }
+        var titleRef: CFTypeRef?
+        guard AXUIElementCopyAttributeValue(window as! AXUIElement, kAXTitleAttribute as CFString, &titleRef) == .success,
+              let title = titleRef as? String else { return nil }
+        return title
+    }
+
     // MARK: - Paste
 
-    func pasteIntoFrontApp(_ text: String) {
+    func pasteIntoFrontApp(_ text: String, targetAppBundleIdentifier: String? = nil) {
         let pb = NSPasteboard.general
         pb.clearContents()
         pb.setString(text, forType: .string)
 
-        // Activate the last user app (not us)
         let myPID = ProcessInfo.processInfo.processIdentifier
-        if let target = NSWorkspace.shared.runningApplications.first(where: {
+        let runningApps = NSWorkspace.shared.runningApplications
+        let targetApp = runningApps.first(where: {
+            guard $0.processIdentifier != myPID, $0.activationPolicy == .regular else { return false }
+            guard let bundleIdentifier = targetAppBundleIdentifier else { return false }
+            return $0.bundleIdentifier == bundleIdentifier
+        }) ?? runningApps.first(where: {
             $0.activationPolicy == .regular && $0.processIdentifier != myPID
-        }) {
-            target.activate()
-        }
+        })
+
+        targetApp?.activate()
 
-        // Wait for activation, then Cmd+V
-        DispatchQueue.main.asyncAfter(deadline: .now() + 0.2) {
+        DispatchQueue.main.asyncAfter(deadline: .now() + 0.1) {
             self.postKey(0x09, flags: .maskCommand)
+            self.updateStatus()
         }
     }
 
     private func postKey(_ key: CGKeyCode, flags: CGEventFlags) {
         let src = CGEventSource(stateID: .hidSystemState)
-        let down = CGEvent(keyboardEventSource: src, virtualKey: key, keyDown: true)
-        down?.flags = flags
-        down?.post(tap: .cghidEventTap)
-        let up = CGEvent(keyboardEventSource: src, virtualKey: key, keyDown: false)
-        up?.flags = flags
-        up?.post(tap: .cghidEventTap)
+        guard let down = CGEvent(keyboardEventSource: src, virtualKey: key, keyDown: true),
+              let up = CGEvent(keyboardEventSource: src, virtualKey: key, keyDown: false) else { return }
+        down.flags = flags
+        up.flags = flags
+        down.post(tap: .cgSessionEventTap)
+        up.post(tap: .cgSessionEventTap)
     }
 }
 
@@ -324,19 +402,41 @@ enum CLIRunner: Sendable {
         let bin = "\(home)/.bun/bin/recordings"
         let escaped = args.map { "\"\($0)\"" }.joined(separator: " ")
         let proc = Process()
-        let pipe = Pipe()
+        let outPipe = Pipe()
+        let errPipe = Pipe()
         proc.executableURL = URL(fileURLWithPath: "/bin/bash")
         proc.arguments = ["-c", """
             export PATH="\(home)/.bun/bin:/opt/homebrew/bin:/usr/local/bin:$PATH"
             "\(bin)" \(escaped)
         """]
-        proc.standardOutput = pipe
-        proc.standardError = FileHandle.nullDevice
+        proc.standardOutput = outPipe
+        proc.standardError = errPipe
         do {
             try proc.run()
             proc.waitUntilExit()
-            return String(data: pipe.fileHandleForReading.readDataToEndOfFile(), encoding: .utf8) ?? ""
-        } catch { return "" }
+            let stdout = String(data: outPipe.fileHandleForReading.readDataToEndOfFile(), encoding: .utf8) ?? ""
+            let stderr = String(data: errPipe.fileHandleForReading.readDataToEndOfFile(), encoding: .utf8) ?? ""
+            if proc.terminationStatus != 0 {
+                let details = stderr.isEmpty ? stdout : stderr
+                return "ERROR: \(details.trimmingCharacters(in: .whitespacesAndNewlines))"
+            }
+            return stdout.isEmpty ? stderr : stdout
+        } catch {
+            return "ERROR: \(error.localizedDescription)"
+        }
+    }
+
+    static func parseError(_ output: String) -> String? {
+        let trimmed = output.trimmingCharacters(in: .whitespacesAndNewlines)
+        guard trimmed.hasPrefix("ERROR:") else { return nil }
+        let message = trimmed.dropFirst("ERROR:".count).trimmingCharacters(in: .whitespacesAndNewlines)
+        if message.contains("OpenAI API key not configured") {
+            return "OpenAI API key not configured on this Mac"
+        }
+        if message.isEmpty {
+            return "Transcription failed"
+        }
+        return String(message.prefix(120))
     }
 
     static func parseJSON(_ output: String) -> String? {
@@ -350,6 +450,6 @@ enum CLIRunner: Sendable {
         }
         return output.components(separatedBy: "\n")
             .map { $0.trimmingCharacters(in: .whitespacesAndNewlines) }
-            .first { !$0.isEmpty && !$0.hasPrefix("{") && !$0.contains("Transcribing") && !$0.hasPrefix("Saved") }
+            .first { !$0.isEmpty && !$0.hasPrefix("{") && !$0.contains("Transcribing") && !$0.hasPrefix("Saved") && !$0.hasPrefix("ERROR:") }
     }
 }

package/src/native/Recordings/Recordings/RecordingsApp.swift

@@ -1,3 +1,4 @@
+@preconcurrency import Cocoa
 import SwiftUI
 import KeyboardShortcuts
 
@@ -5,11 +6,19 @@ import KeyboardShortcuts
 struct RecordingsApp: App {
     @StateObject private var engine = RecordingEngine()
     @StateObject private var shortcuts = VoiceShortcuts()
+    @StateObject private var projectStore = ProjectStore()
+
+    init() {
+        AXIsProcessTrustedWithOptions(
+            [kAXTrustedCheckOptionPrompt.takeUnretainedValue(): true] as CFDictionary
+        )
+    }
 
     var body: some Scene {
         MenuBarExtra {
-            MenuBarPopover(engine: engine, shortcuts: shortcuts)
-                .frame(width: 320, height: 440)
+            MenuBarPopover(engine: engine, shortcuts: shortcuts, projectStore: projectStore)
+                .frame(width: 320, height: 420)
+                .onAppear { engine.projectStore = projectStore }
         } label: {
             if engine.isRecording {
                 Image(systemName: "record.circle.fill")
@@ -22,9 +31,8 @@ struct RecordingsApp: App {
         }
         .menuBarExtraStyle(.window)
 
-        // Settings window — opened via SettingsLink
         Settings {
-            SettingsView(engine: engine, shortcuts: shortcuts)
+            SettingsView(engine: engine, shortcuts: shortcuts, projectStore: projectStore)
         }
     }
 }