@hasna/recordings 0.1.3 → 0.1.6

package/src/native/Recordings/Recordings/MenuBarPopover.swift

@@ -0,0 +1,188 @@
+import SwiftUI
+import KeyboardShortcuts
+
+struct MenuBarPopover: View {
+    @ObservedObject var engine: RecordingEngine
+    @ObservedObject var shortcuts: VoiceShortcuts
+
+    var body: some View {
+        VStack(spacing: 0) {
+            header.padding(.horizontal, 16).padding(.top, 12).padding(.bottom, 8)
+            Divider()
+            modeSelector.padding(.horizontal, 16).padding(.vertical, 10)
+            shortcutRow.padding(.horizontal, 16).padding(.bottom, 8)
+            Divider()
+            recordingArea.padding(.horizontal, 16).padding(.vertical, 12)
+            Divider()
+            recentList.frame(maxHeight: 180)
+            Divider()
+            footer.padding(.horizontal, 16).padding(.vertical, 8)
+        }
+    }
+
+    // MARK: - Header
+
+    private var header: some View {
+        HStack {
+            Image(systemName: "mic.fill").font(.title3).foregroundStyle(.tint)
+            Text("Recordings").font(.headline)
+            Spacer()
+            Toggle(isOn: $engine.isWhisperMode) {
+                Label("Whisper", systemImage: "speaker.wave.1.fill").font(.caption)
+            }
+            .toggleStyle(.button).buttonStyle(.bordered).controlSize(.small)
+        }
+    }
+
+    // MARK: - Mode Selector
+
+    private var modeSelector: some View {
+        HStack(spacing: 8) {
+            modeBtn(.pushToTalk)
+            modeBtn(.dictation)
+            modeBtn(.command)
+        }
+    }
+
+    @ViewBuilder
+    private func modeBtn(_ m: RecordingMode) -> some View {
+        if engine.mode == m {
+            Button { engine.mode = m } label: {
+                Label(m.rawValue, systemImage: m.icon).font(.caption)
+                    .foregroundStyle(.white).frame(maxWidth: .infinity)
+            }.buttonStyle(.borderedProminent).controlSize(.small)
+        } else {
+            Button { engine.mode = m } label: {
+                Label(m.rawValue, systemImage: m.icon).font(.caption)
+                    .frame(maxWidth: .infinity)
+            }.buttonStyle(.bordered).controlSize(.small)
+        }
+    }
+
+    // MARK: - Shortcut Row
+
+    private var shortcutRow: some View {
+        VStack(spacing: 6) {
+            // fn key toggle
+            HStack {
+                Toggle(isOn: $engine.useFnKey) {
+                    HStack(spacing: 4) {
+                        Text("fn").font(.system(.caption, design: .monospaced)).bold()
+                        Text("Globe key").font(.caption).foregroundStyle(.secondary)
+                    }
+                }
+                .toggleStyle(.switch).controlSize(.small)
+            }
+
+            // Custom shortcut
+            HStack(spacing: 8) {
+                Text("Custom").font(.caption).foregroundStyle(.secondary)
+                Spacer()
+                let current = KeyboardShortcuts.getShortcut(for: .toggleRecording)
+                Text(current?.description ?? "None")
+                    .font(.system(.caption, design: .monospaced))
+                    .padding(.horizontal, 8).padding(.vertical, 3)
+                    .background(.quaternary, in: RoundedRectangle(cornerRadius: 5))
+
+                SettingsLink {
+                    Text("Set").font(.caption2)
+                }.buttonStyle(.bordered).controlSize(.mini)
+            }
+        }
+    }
+
+    // MARK: - Recording Area
+
+    private var recordingArea: some View {
+        VStack(spacing: 8) {
+            if engine.isRecording {
+                HStack(spacing: 12) {
+                    Circle().fill(.red).frame(width: 10, height: 10)
+                    Text(fmt(engine.recordingDuration))
+                        .font(.system(.title2, design: .monospaced))
+                    Spacer()
+                    Button("Stop") { engine.stopAndTranscribe() }
+                        .buttonStyle(.borderedProminent).tint(.red).controlSize(.small)
+                }
+                .padding(12).glassEffect(.regular.tint(.red))
+            } else if engine.isTranscribing {
+                HStack(spacing: 8) {
+                    ProgressView().controlSize(.small)
+                    Text("Transcribing...").font(.subheadline).foregroundStyle(.secondary)
+                }
+                .frame(maxWidth: .infinity).padding(12).glassEffect(.regular)
+            } else {
+                VStack(spacing: 10) {
+                    Button { engine.startRecording() } label: {
+                        Label("Record", systemImage: "mic.circle.fill").font(.title3)
+                    }.buttonStyle(.borderedProminent).controlSize(.large)
+
+                    Text(engine.mode.hint)
+                        .font(.callout).foregroundStyle(.primary.opacity(0.7))
+                        .multilineTextAlignment(.center)
+                        .fixedSize(horizontal: false, vertical: true)
+                }
+                .frame(maxWidth: .infinity).padding(14).glassEffect(.clear)
+            }
+
+            Text(engine.statusMessage)
+                .font(.caption2).foregroundStyle(.secondary)
+                .lineLimit(2).truncationMode(.tail)
+                .frame(maxWidth: .infinity, alignment: .leading)
+        }
+    }
+
+    // MARK: - Recent
+
+    private var recentList: some View {
+        Group {
+            if engine.recentTranscriptions.isEmpty {
+                VStack { Spacer()
+                    Text("No recent transcriptions").font(.caption).foregroundStyle(.quaternary)
+                    Spacer()
+                }.frame(maxWidth: .infinity)
+            } else {
+                ScrollView {
+                    LazyVStack(alignment: .leading, spacing: 4) {
+                        ForEach(engine.recentTranscriptions.indices, id: \.self) { i in
+                            TranscriptionRow(item: engine.recentTranscriptions[i])
+                        }
+                    }.padding(.horizontal, 16).padding(.vertical, 6)
+                }
+            }
+        }
+    }
+
+    // MARK: - Footer
+
+    private var footer: some View {
+        HStack {
+            SettingsLink { Image(systemName: "gear") }.buttonStyle(.borderless)
+            Spacer()
+            Button("Quit") { NSApplication.shared.terminate(nil) }
+                .buttonStyle(.borderless).foregroundStyle(.secondary)
+        }
+    }
+
+    private func fmt(_ t: TimeInterval) -> String {
+        String(format: "%d:%02d", Int(t) / 60, Int(t) % 60)
+    }
+}
+
+struct TranscriptionRow: View {
+    let item: TranscriptionResult
+    var body: some View {
+        HStack(alignment: .top, spacing: 8) {
+            Text(item.displayText).font(.caption).lineLimit(2)
+                .frame(maxWidth: .infinity, alignment: .leading)
+            Text({ let s = Date().timeIntervalSince(item.timestamp)
+                return s < 60 ? "now" : s < 3600 ? "\(Int(s/60))m" : "\(Int(s/3600))h"
+            }()).font(.caption2).foregroundStyle(.tertiary)
+        }
+        .padding(.vertical, 4).contentShape(Rectangle())
+        .onTapGesture {
+            NSPasteboard.general.clearContents()
+            NSPasteboard.general.setString(item.displayText, forType: .string)
+        }
+    }
+}

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

@@ -0,0 +1,355 @@
+import SwiftUI
+import KeyboardShortcuts
+
+// MARK: - Custom shortcut (not fn — fn is handled by FnKeyMonitor)
+
+extension KeyboardShortcuts.Name {
+    static let toggleRecording = Self("toggleRecording")
+}
+
+// MARK: - Recording Mode
+
+enum RecordingMode: String, CaseIterable, Identifiable, Sendable {
+    case pushToTalk = "Push to Talk"
+    case dictation = "Dictation"
+    case command = "Command"
+
+    var id: String { rawValue }
+    var icon: String {
+        switch self {
+        case .pushToTalk: return "hand.tap.fill"
+        case .dictation: return "text.bubble.fill"
+        case .command: return "wand.and.stars"
+        }
+    }
+    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"
+        }
+    }
+}
+
+// MARK: - Transcription Result
+
+struct TranscriptionResult: Sendable {
+    let rawText: String
+    let processedText: String?
+    let timestamp: Date
+    var displayText: String { processedText ?? rawText }
+}
+
+// MARK: - Recording Engine
+
+@MainActor
+final class RecordingEngine: ObservableObject {
+    @Published var isRecording = false
+    @Published var mode: RecordingMode = .pushToTalk
+    @Published var useFnKey: Bool = true {
+        didSet {
+            UserDefaults.standard.set(useFnKey, forKey: "useFnKey")
+            updateFnMonitor()
+            updateStatus()
+        }
+    }
+    @Published var isWhisperMode = false
+    @Published var recentTranscriptions: [TranscriptionResult] = []
+    @Published var statusMessage = "Starting..."
+    @Published var isTranscribing = false
+    @Published var recordingDuration: TimeInterval = 0
+
+    private var recordProcess: Process?
+    private var stdinPipe: Pipe?
+    private var currentAudioPath: String?
+    private var recordingTimer: Timer?
+    private let maxDuration = 300
+
+    // fn key monitor (CGEventTap-based, swallows fn to prevent emoji picker)
+    private let fnMonitor = FnKeyMonitor()
+
+    let home = FileManager.default.homeDirectoryForCurrentUser.path
+    private var audioDir: String { "\(home)/.recordings/audio" }
+
+    init() {
+        try? FileManager.default.createDirectory(atPath: audioDir, withIntermediateDirectories: true)
+
+        // Load preferences
+        useFnKey = UserDefaults.standard.object(forKey: "useFnKey") as? Bool ?? true
+
+        // 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()
+            }
+        }
+        fnMonitor.onFnKeyUp = { [weak self] in
+            Task { @MainActor [weak self] in
+                guard let self, self.useFnKey, self.isRecording else { return }
+                self.stopAndTranscribe()
+            }
+        }
+        updateFnMonitor()
+
+        // Set up custom shortcut (toggle mode — press to start, press to stop)
+        KeyboardShortcuts.onKeyUp(for: .toggleRecording) { [weak self] in
+            Task { @MainActor [weak self] in
+                self?.toggleRecording()
+            }
+        }
+
+        updateStatus()
+    }
+
+    private func updateFnMonitor() {
+        if useFnKey {
+            let ok = fnMonitor.start()
+            if !ok {
+                statusMessage = "fn needs Accessibility permission (System Settings > Privacy & Security > Accessibility)"
+            }
+        } else {
+            fnMonitor.stop()
+        }
+    }
+
+    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"
+        }
+    }
+
+    // MARK: - Toggle
+
+    func toggleRecording() {
+        if isRecording { stopAndTranscribe() } else { startRecording() }
+    }
+
+    // MARK: - Start Recording
+
+    func startRecording() {
+        guard !isRecording else { return }
+
+        let ts = DateFormatter()
+        ts.dateFormat = "yyyyMMdd'T'HHmmss"
+        let path = "\(audioDir)/rec-\(ts.string(from: Date())).wav"
+        currentAudioPath = path
+
+        let proc = Process()
+        let stdin = 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
+            elif command -v rec &>/dev/null; then
+                rec -r 16000 -c 1 -b 16 "\(path)" trim 0 \(maxDuration)
+            else
+                exit 1
+            fi
+        """]
+        proc.standardInput = stdin
+        proc.standardOutput = FileHandle.nullDevice
+        proc.standardError = FileHandle.nullDevice
+
+        do {
+            try proc.run()
+            recordProcess = proc
+            stdinPipe = stdin
+            isRecording = true
+            recordingDuration = 0
+            statusMessage = mode == .command ? "Speak your instruction..." : "Recording — press fn to stop"
+
+            recordingTimer = Timer.scheduledTimer(withTimeInterval: 0.1, repeats: true) { [weak self] _ in
+                Task { @MainActor [weak self] in
+                    self?.recordingDuration += 0.1
+                }
+            }
+        } catch {
+            statusMessage = "Failed: \(error.localizedDescription)"
+        }
+    }
+
+    // MARK: - Stop & Transcribe
+
+    func stopAndTranscribe() {
+        guard let proc = recordProcess else { return }
+
+        recordingTimer?.invalidate()
+        recordingTimer = nil
+
+        if let pipe = stdinPipe {
+            try? pipe.fileHandleForWriting.write(contentsOf: Data("q".utf8))
+            try? pipe.fileHandleForWriting.close()
+        }
+
+        isRecording = false
+        isTranscribing = true
+        statusMessage = "Transcribing..."
+
+        let audioPath = currentAudioPath
+        let curMode = mode
+        currentAudioPath = nil
+        recordProcess = nil
+        stdinPipe = nil
+        let homePath = home
+
+        Task.detached {
+            try? await Task.sleep(for: .seconds(1))
+            if proc.isRunning { proc.terminate() }
+            try? await Task.sleep(for: .milliseconds(300))
+            if proc.isRunning { proc.interrupt() }
+
+            guard let audioPath else {
+                await MainActor.run { self.finish("No audio file") }
+                return
+            }
+
+            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") }
+                return
+            }
+
+            let output = CLIRunner.run(["transcribe", audioPath, "--json"], home: homePath)
+            let text = CLIRunner.parseJSON(output)
+
+            guard let text, !text.isEmpty else {
+                await MainActor.run { self.finish("Empty transcription") }
+                return
+            }
+
+            await MainActor.run {
+                self.isTranscribing = false
+                if curMode == .command {
+                    self.runCommandMode(instruction: text)
+                } else {
+                    self.pasteIntoFrontApp(text)
+                    self.recentTranscriptions.insert(
+                        TranscriptionResult(rawText: text, processedText: nil, timestamp: Date()), at: 0
+                    )
+                    if self.recentTranscriptions.count > 20 { self.recentTranscriptions.removeLast() }
+                    self.statusMessage = "Pasted: \(String(text.prefix(50)))"
+                }
+            }
+        }
+    }
+
+    private func finish(_ msg: String) {
+        isTranscribing = false
+        statusMessage = msg
+    }
+
+    // MARK: - Command Mode
+
+    private func runCommandMode(instruction: String) {
+        postKey(0x08, flags: .maskCommand) // Cmd+C
+        let homePath = home
+
+        Task {
+            try? await Task.sleep(for: .milliseconds(250))
+            let selected = NSPasteboard.general.string(forType: .string) ?? ""
+            guard !selected.isEmpty else {
+                statusMessage = "No text selected"
+                return
+            }
+            statusMessage = "Rewriting..."
+            isTranscribing = true
+            let prompt = "Rewrite: \"\(instruction)\"\n\nText:\n\(selected)"
+
+            Task.detached {
+                let result = CLIRunner.run(["transcribe", "--text", prompt, "--enhance"], home: homePath)
+                await MainActor.run {
+                    self.isTranscribing = false
+                    if !result.isEmpty {
+                        self.pasteIntoFrontApp(result)
+                        self.statusMessage = "Rewritten"
+                    } else {
+                        self.statusMessage = "Rewrite failed"
+                    }
+                }
+            }
+        }
+    }
+
+    // MARK: - Paste
+
+    func pasteIntoFrontApp(_ text: String) {
+        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: {
+            $0.activationPolicy == .regular && $0.processIdentifier != myPID
+        }) {
+            target.activate()
+        }
+
+        // Wait for activation, then Cmd+V
+        DispatchQueue.main.asyncAfter(deadline: .now() + 0.2) {
+            self.postKey(0x09, flags: .maskCommand)
+        }
+    }
+
+    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)
+    }
+}
+
+// MARK: - CLI Runner
+
+enum CLIRunner: Sendable {
+    static func run(_ args: [String], home: String) -> String {
+        let bin = "\(home)/.bun/bin/recordings"
+        let escaped = args.map { "\"\($0)\"" }.joined(separator: " ")
+        let proc = Process()
+        let pipe = 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
+        do {
+            try proc.run()
+            proc.waitUntilExit()
+            return String(data: pipe.fileHandleForReading.readDataToEndOfFile(), encoding: .utf8) ?? ""
+        } catch { return "" }
+    }
+
+    static func parseJSON(_ output: String) -> String? {
+        if let s = output.range(of: "{"), let e = output.range(of: "}", options: .backwards) {
+            let json = String(output[s.lowerBound...e.upperBound])
+            if let data = json.data(using: .utf8),
+               let obj = try? JSONSerialization.jsonObject(with: data) as? [String: Any] {
+                if let t = obj["processed_text"] as? String, !t.isEmpty { return t }
+                if let t = obj["raw_text"] as? String, !t.isEmpty { return t }
+            }
+        }
+        return output.components(separatedBy: "\n")
+            .map { $0.trimmingCharacters(in: .whitespacesAndNewlines) }
+            .first { !$0.isEmpty && !$0.hasPrefix("{") && !$0.contains("Transcribing") && !$0.hasPrefix("Saved") }
+    }
+}

package/src/native/Recordings/Recordings/Recordings.entitlements

@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>com.apple.security.app-sandbox</key>
+    <false/>
+    <key>com.apple.security.device.audio-input</key>
+    <true/>
+    <key>com.apple.security.automation.apple-events</key>
+    <true/>
+</dict>
+</plist>

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

@@ -0,0 +1,30 @@
+import SwiftUI
+import KeyboardShortcuts
+
+@main
+struct RecordingsApp: App {
+    @StateObject private var engine = RecordingEngine()
+    @StateObject private var shortcuts = VoiceShortcuts()
+
+    var body: some Scene {
+        MenuBarExtra {
+            MenuBarPopover(engine: engine, shortcuts: shortcuts)
+                .frame(width: 320, height: 440)
+        } label: {
+            if engine.isRecording {
+                Image(systemName: "record.circle.fill")
+                    .symbolRenderingMode(.multicolor)
+            } else if engine.isTranscribing {
+                Image(systemName: "ellipsis.circle")
+            } else {
+                Image(systemName: "mic.fill")
+            }
+        }
+        .menuBarExtraStyle(.window)
+
+        // Settings window — opened via SettingsLink
+        Settings {
+            SettingsView(engine: engine, shortcuts: shortcuts)
+        }
+    }
+}

package/src/native/Recordings/Recordings/SettingsView.swift

@@ -0,0 +1,93 @@
+import SwiftUI
+import KeyboardShortcuts
+
+struct SettingsView: View {
+    @ObservedObject var engine: RecordingEngine
+    @ObservedObject var shortcuts: VoiceShortcuts
+    @State private var newTrigger = ""
+    @State private var newContent = ""
+
+    var body: some View {
+        TabView {
+            generalTab.tabItem { Label("General", systemImage: "gear") }
+            shortcutsTab.tabItem { Label("Voice Shortcuts", systemImage: "text.badge.star") }
+        }
+        .frame(width: 480, height: 400)
+    }
+
+    private var generalTab: some View {
+        Form {
+            Section("Shortcut — fn Key") {
+                Toggle("Use fn (Globe) key", isOn: $engine.useFnKey)
+
+                if engine.useFnKey {
+                    Text("Hold fn to record, release to stop and paste.")
+                        .font(.caption).foregroundStyle(.secondary)
+                    HStack(spacing: 4) {
+                        Image(systemName: "exclamationmark.triangle.fill")
+                            .foregroundStyle(.orange)
+                        Text("Required: System Settings → Keyboard → set \"Press 🌐 key to: Do Nothing\"")
+                            .font(.caption)
+                    }
+                    Button("Open Keyboard Settings") {
+                        NSWorkspace.shared.open(URL(string: "x-apple.systempreferences:com.apple.Keyboard-Settings.extension")!)
+                    }.controlSize(.small)
+                }
+            }
+
+            Section("Shortcut — Custom Key") {
+                HStack {
+                    Text("Toggle Recording")
+                    Spacer()
+                    KeyboardShortcuts.Recorder(for: .toggleRecording) { _ in
+                        engine.updateStatus()
+                    }
+                }
+                Text("Click the field and press any key combo (e.g. ⌥D, ⌃R, F5).")
+                    .font(.caption).foregroundStyle(.secondary)
+            }
+
+            Section("Recording") {
+                Picker("Mode", selection: $engine.mode) {
+                    ForEach(RecordingMode.allCases) { m in
+                        Label(m.rawValue, systemImage: m.icon).tag(m)
+                    }
+                }
+                Toggle("Whisper Mode", isOn: $engine.isWhisperMode)
+            }
+        }
+        .formStyle(.grouped).padding()
+    }
+
+    private var shortcutsTab: some View {
+        VStack(spacing: 0) {
+            HStack(spacing: 8) {
+                TextField("Trigger phrase", text: $newTrigger).textFieldStyle(.roundedBorder)
+                TextField("Text to insert", text: $newContent).textFieldStyle(.roundedBorder)
+                Button("Add") {
+                    guard !newTrigger.isEmpty, !newContent.isEmpty else { return }
+                    shortcuts.add(trigger: newTrigger, content: newContent)
+                    newTrigger = ""; newContent = ""
+                }.buttonStyle(.borderedProminent).disabled(newTrigger.isEmpty || newContent.isEmpty)
+            }.padding()
+            Divider()
+            if shortcuts.shortcuts.isEmpty {
+                Spacer()
+                VStack(spacing: 8) {
+                    Image(systemName: "text.badge.star").font(.largeTitle).foregroundStyle(.quaternary)
+                    Text("No voice shortcuts yet").foregroundStyle(.secondary)
+                }
+                Spacer()
+            } else {
+                List {
+                    ForEach(shortcuts.shortcuts) { s in
+                        VStack(alignment: .leading) {
+                            Text(s.trigger).font(.body.bold())
+                            Text(s.content).font(.caption).foregroundStyle(.secondary).lineLimit(2)
+                        }
+                    }.onDelete(perform: shortcuts.remove)
+                }
+            }
+        }
+    }
+}