@hasna/recordings 0.1.10 → 0.1.12

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

@@ -0,0 +1,218 @@
+import SwiftUI
+import KeyboardShortcuts
+
+public struct SettingsView: View {
+    @ObservedObject public var engine: RecordingEngine
+    @ObservedObject public var shortcuts: VoiceShortcuts
+    @ObservedObject public var projectStore: ProjectStore
+    @AppStorage("openAIAPIKey") private var openAIAPIKey = ""
+
+    public init(engine: RecordingEngine, shortcuts: VoiceShortcuts, projectStore: ProjectStore) {
+        self.engine = engine
+        self.shortcuts = shortcuts
+        self.projectStore = projectStore
+    }
+
+    public var body: some View {
+        TabView {
+            generalTab.tabItem { Label("General", systemImage: "gear") }
+            projectsTab.tabItem { Label("Projects", systemImage: "folder") }
+            shortcutsTab.tabItem { Label("Voice Shortcuts", systemImage: "text.badge.star") }
+        }
+        .frame(width: 520, height: 440)
+    }
+
+    // MARK: - General
+
+    private var generalTab: some View {
+        Form {
+            Section("OpenAI") {
+                SecureField("API key", text: $openAIAPIKey)
+                    .textFieldStyle(.roundedBorder)
+                Text("Used for realtime transcription in the menu bar app.")
+                    .foregroundStyle(.secondary)
+            }
+
+            Section("Recording Shortcut") {
+                HStack {
+                    Text("Shortcut")
+                    Spacer()
+                    KeyboardShortcuts.Recorder(for: .toggleRecording) { _ in
+                        engine.updateStatus()
+                    }
+                }
+                Text("Hold to record, release to transcribe and paste.")
+                    .foregroundStyle(.secondary)
+            }
+
+            Section("System Prompt") {
+                TextEditor(text: $projectStore.settings.globalSystemPrompt)
+                    .frame(height: 80)
+                    .onChange(of: projectStore.settings.globalSystemPrompt) {
+                        projectStore.save()
+                    }
+                Text("Applied to all transcription enhancements.")
+                    .foregroundStyle(.secondary)
+            }
+        }
+        .formStyle(.grouped).padding()
+    }
+
+    // MARK: - Projects
+
+    @State private var newProjectName = ""
+    @State private var editingProject: RecProject?
+
+    private var projectsTab: some View {
+        VStack(spacing: 0) {
+            HStack(spacing: 8) {
+                TextField("New project name", text: $newProjectName)
+                    .textFieldStyle(.roundedBorder)
+                Button("Add") {
+                    guard !newProjectName.isEmpty else { return }
+                    projectStore.addProject(name: newProjectName)
+                    newProjectName = ""
+                }
+                .disabled(newProjectName.isEmpty)
+            }
+            .padding()
+
+            Divider()
+
+            if projectStore.settings.projects.isEmpty {
+                Spacer()
+                VStack(spacing: 8) {
+                    Image(systemName: "folder").font(.largeTitle).foregroundStyle(.quaternary)
+                    Text("No projects yet").foregroundStyle(.secondary)
+                }
+                Spacer()
+            } else {
+                List {
+                    ForEach(projectStore.settings.projects) { project in
+                        ProjectRow(project: project) {
+                            editingProject = project
+                        }
+                    }
+                    .onDelete { indexSet in
+                        for i in indexSet {
+                            projectStore.removeProject(id: projectStore.settings.projects[i].id)
+                        }
+                    }
+                }
+            }
+        }
+        .sheet(item: $editingProject) { project in
+            ProjectEditView(project: project, store: projectStore) {
+                editingProject = nil
+            }
+        }
+    }
+
+    // MARK: - Voice Shortcuts
+
+    @State private var newTrigger = ""
+    @State private var newContent = ""
+
+    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 = ""
+                }
+                .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).bold()
+                            Text(s.content).foregroundStyle(.secondary).lineLimit(2)
+                        }
+                    }
+                    .onDelete(perform: shortcuts.remove)
+                }
+            }
+        }
+    }
+}
+
+// MARK: - Project Row
+
+struct ProjectRow: View {
+    let project: RecProject
+    let onEdit: () -> Void
+
+    var body: some View {
+        HStack {
+            VStack(alignment: .leading, spacing: 2) {
+                Text(project.name)
+                if let path = project.path, !path.isEmpty {
+                    Text(path).foregroundStyle(.secondary).lineLimit(1)
+                }
+            }
+            Spacer()
+            Button("Edit") { onEdit() }
+                .controlSize(.small)
+        }
+    }
+}
+
+// MARK: - Project Edit
+
+struct ProjectEditView: View {
+    @State var project: RecProject
+    let store: ProjectStore
+    let onDismiss: () -> Void
+
+    var body: some View {
+        VStack(spacing: 0) {
+            Form {
+                Section("Project") {
+                    TextField("Name", text: $project.name)
+                    TextField("Path", text: Binding(
+                        get: { project.path ?? "" },
+                        set: { project.path = $0.isEmpty ? nil : $0 }
+                    ))
+                    .textFieldStyle(.roundedBorder)
+                }
+
+                Section("System Prompt") {
+                    TextEditor(text: Binding(
+                        get: { project.systemPrompt ?? "" },
+                        set: { project.systemPrompt = $0.isEmpty ? nil : $0 }
+                    ))
+                    .frame(height: 100)
+                    Text("Additional context for transcription enhancement in this project.")
+                        .foregroundStyle(.secondary)
+                }
+            }
+            .formStyle(.grouped)
+
+            HStack {
+                Spacer()
+                Button("Cancel") { onDismiss() }
+                Button("Save") {
+                    store.updateProject(project)
+                    onDismiss()
+                }
+            }
+            .padding()
+        }
+        .frame(width: 420, height: 340)
+    }
+}

package/src/native/Recordings/{Recordings → RecordingsLib}/VoiceShortcuts.swift

@@ -2,12 +2,12 @@ import SwiftUI
 
 // MARK: - Voice Shortcut
 
-struct VoiceShortcut: Identifiable, Codable {
-    let id: UUID
-    var trigger: String   // e.g. "add disclaimer"
-    var content: String   // text to insert when trigger is spoken
+public struct VoiceShortcut: Identifiable, Codable {
+    public let id: UUID
+    public var trigger: String   // e.g. "add disclaimer"
+    public var content: String   // text to insert when trigger is spoken
 
-    init(trigger: String, content: String) {
+    public init(trigger: String, content: String) {
         self.id = UUID()
         self.trigger = trigger
         self.content = content
@@ -17,15 +17,15 @@ struct VoiceShortcut: Identifiable, Codable {
 // MARK: - Voice Shortcuts Manager
 
 @MainActor
-final class VoiceShortcuts: ObservableObject {
-    @Published var shortcuts: [VoiceShortcut] = []
+public final class VoiceShortcuts: ObservableObject {
+    @Published public var shortcuts: [VoiceShortcut] = []
 
     private let storageURL: URL = {
         let home = FileManager.default.homeDirectoryForCurrentUser
         return home.appendingPathComponent(".hasna/recordings/voice-shortcuts.json")
     }()
 
-    init() {
+    public init() {
         load()
     }
 
@@ -64,6 +64,10 @@ final class VoiceShortcuts: ObservableObject {
     private func save() {
         do {
             let data = try JSONEncoder().encode(shortcuts)
+            try FileManager.default.createDirectory(
+                at: storageURL.deletingLastPathComponent(),
+                withIntermediateDirectories: true
+            )
             try data.write(to: storageURL, options: .atomic)
         } catch {
             print("Failed to save voice shortcuts: \(error)")

package/src/native/Recordings/RecordingsTests/CLIRunnerTests.swift

@@ -0,0 +1,63 @@
+import Testing
+@testable import RecordingsLib
+
+struct CLIRunnerTests {
+    @Test("parseError detects ERROR prefix")
+    func parseError() {
+        #expect(CLIRunner.parseError("ERROR: OpenAI API key not configured on this Mac") == "OpenAI API key not configured on this Mac")
+    }
+
+    @Test("parseError returns nil for normal output")
+    func noError() {
+        #expect(CLIRunner.parseError("Hello world") == nil)
+    }
+
+    @Test("parseError handles API key error")
+    func apiKeyError() {
+        #expect(CLIRunner.parseError("ERROR: OpenAI API key not configured") == "OpenAI API key not configured on this Mac")
+    }
+
+    @Test("parseError truncates long messages to 120 chars")
+    func truncation() {
+        let longMsg = String(repeating: "a", count: 200)
+        let input = "ERROR: \(longMsg)"
+        let result = CLIRunner.parseError(input)!
+        #expect(result.count <= 120)
+    }
+
+    @Test("parseJSON extracts raw_text from JSON")
+    func parseJSONRawText() {
+        let output = """
+        {"raw_text": "Hello world", "processed_text": null}
+        """
+        #expect(CLIRunner.parseJSON(output) == "Hello world")
+    }
+
+    @Test("parseJSON prefers processed_text over raw_text")
+    func parseJSONProcessedText() {
+        let output = """
+        {"raw_text": "Hello world", "processed_text": "Hello World (enhanced)"}
+        """
+        #expect(CLIRunner.parseJSON(output) == "Hello World (enhanced)")
+    }
+
+    @Test("parseJSON falls back to plain text")
+    func parseJSONFallback() {
+        let output = "Transcribing...\nHello world\nSaved to file"
+        #expect(CLIRunner.parseJSON(output) == "Hello world")
+    }
+
+    @Test("parseJSON returns nil for empty output")
+    func emptyOutput() {
+        #expect(CLIRunner.parseJSON("") == nil)
+    }
+
+    @Test("parseJSON handles empty transcription")
+    func emptyTranscription() {
+        let output = """
+        {"raw_text": "", "processed_text": ""}
+        """
+        // Both are empty, so it should fall back to plain text extraction
+        #expect(CLIRunner.parseJSON(output) == nil)
+    }
+}

package/src/native/Recordings/RecordingsTests/NativePCMRecorderTests.swift

@@ -0,0 +1,33 @@
+import AVFoundation
+import Testing
+@testable import RecordingsLib
+
+struct NativePCMRecorderTests {
+    @Test("Realtime output format is OpenAI-compatible 24 kHz mono PCM16")
+    func realtimeOutputFormat() throws {
+        let format = try #require(NativePCMRecorder.realtimeOutputFormat())
+
+        #expect(format.commonFormat == .pcmFormatInt16)
+        #expect(format.sampleRate == 24_000)
+        #expect(format.channelCount == 1)
+        #expect(format.isInterleaved)
+    }
+
+    @Test("Extracts PCM16 bytes from audio buffer")
+    func extractPCM16Data() throws {
+        let format = try #require(NativePCMRecorder.realtimeOutputFormat())
+        let buffer = try #require(AVAudioPCMBuffer(pcmFormat: format, frameCapacity: 4))
+        buffer.frameLength = 4
+
+        let samples = try #require(buffer.int16ChannelData?[0])
+        samples[0] = 1
+        samples[1] = -2
+        samples[2] = 3
+        samples[3] = -4
+
+        let data = NativePCMRecorder.extractPCM16Data(from: buffer)
+
+        #expect(data.count == 8)
+        #expect(data.withUnsafeBytes { $0.load(as: Int16.self) } == 1)
+    }
+}

package/src/native/Recordings/RecordingsTests/OpenAIAPIKeyStoreTests.swift

@@ -0,0 +1,92 @@
+import Foundation
+import Testing
+@testable import RecordingsLib
+
+struct OpenAIAPIKeyStoreTests {
+    @Test("Environment key has highest priority")
+    func environmentKeyWins() {
+        let key = OpenAIAPIKeyStore.load(
+            homePath: "/tmp/recordings-missing-home",
+            environment: ["OPENAI_API_KEY": "env-key"],
+            userDefaultKey: "stored-key"
+        )
+        #expect(key == "env-key")
+    }
+
+    @Test("User default key is used before config file")
+    func userDefaultKeyWins() throws {
+        let home = try makeHome()
+        try writeConfig(home: home, ["openai_api_key": "config-key"])
+
+        let key = OpenAIAPIKeyStore.load(
+            homePath: home.path,
+            environment: [:],
+            userDefaultKey: "stored-key"
+        )
+        #expect(key == "stored-key")
+    }
+
+    @Test("Config file key is loaded from installed app data")
+    func configFileKey() throws {
+        let home = try makeHome()
+        try writeConfig(home: home, ["openai_api_key": "config-key"])
+
+        let key = OpenAIAPIKeyStore.load(
+            homePath: home.path,
+            environment: [:],
+            userDefaultKey: nil
+        )
+        #expect(key == "config-key")
+    }
+
+    @Test("Config file can reference environment variable")
+    func configEnvReference() throws {
+        let home = try makeHome()
+        try writeConfig(home: home, ["openai_api_key": "$RECORDINGS_API_KEY"])
+
+        let key = OpenAIAPIKeyStore.load(
+            homePath: home.path,
+            environment: ["RECORDINGS_API_KEY": "referenced-key"],
+            userDefaultKey: nil
+        )
+        #expect(key == "referenced-key")
+    }
+
+    @Test("Secrets env files are searched recursively")
+    func recursiveSecrets() throws {
+        let home = try makeHome()
+        let secretDir = home
+            .appendingPathComponent(".secrets")
+            .appendingPathComponent("hasnaxyz")
+            .appendingPathComponent("openai")
+        try FileManager.default.createDirectory(at: secretDir, withIntermediateDirectories: true)
+        try "export OPENAI_API_KEY='secret-key'\n".write(
+            to: secretDir.appendingPathComponent("live.env"),
+            atomically: true,
+            encoding: .utf8
+        )
+
+        let key = OpenAIAPIKeyStore.load(
+            homePath: home.path,
+            environment: [:],
+            userDefaultKey: nil
+        )
+        #expect(key == "secret-key")
+    }
+
+    private func makeHome() throws -> URL {
+        let url = FileManager.default.temporaryDirectory
+            .appendingPathComponent("recordings-key-store-\(UUID().uuidString)")
+        try FileManager.default.createDirectory(at: url, withIntermediateDirectories: true)
+        return url
+    }
+
+    private func writeConfig(home: URL, _ config: [String: String]) throws {
+        let configDir = home
+            .appendingPathComponent(".hasna")
+            .appendingPathComponent("recordings")
+        try FileManager.default.createDirectory(at: configDir, withIntermediateDirectories: true)
+        let data = try JSONSerialization.data(withJSONObject: config, options: [.prettyPrinted])
+        try data.write(to: configDir.appendingPathComponent("config.json"))
+    }
+}

package/src/native/Recordings/RecordingsTests/ProjectStoreTests.swift

@@ -0,0 +1,58 @@
+import Testing
+@testable import RecordingsLib
+
+struct ProjectStoreTests {
+    @Test("matchProject by bundle ID")
+    func matchByBundleId() {
+        let projects = [
+            RecProject(name: "MyApp", appBundleIds: ["com.example.myapp"]),
+            RecProject(name: "Other", appBundleIds: ["com.example.other"]),
+        ]
+        let result = ProjectStore.matchProject(windowTitle: nil, bundleId: "com.example.myapp", projects: projects)
+        #expect(result?.name == "MyApp")
+    }
+
+    @Test("matchProject by window title containing project name")
+    func matchByWindowTitle() {
+        let projects = [
+            RecProject(name: "Hasna", path: nil),
+            RecProject(name: "Other", path: nil),
+        ]
+        let result = ProjectStore.matchProject(windowTitle: "Hasna — Takumi", bundleId: nil, projects: projects)
+        #expect(result?.name == "Hasna")
+    }
+
+    @Test("matchProject by path component in window title")
+    func matchByPathComponent() {
+        let projects = [
+            RecProject(name: "Backend API", path: "/projects/backend-api"),
+            RecProject(name: "Other", path: nil),
+        ]
+        let result = ProjectStore.matchProject(windowTitle: "backend-api — VSCode", bundleId: nil, projects: projects)
+        #expect(result?.name == "Backend API")
+    }
+
+    @Test("matchProject returns nil when no match")
+    func noMatch() {
+        let projects = [
+            RecProject(name: "ProjectA", appBundleIds: ["com.a"]),
+        ]
+        let result = ProjectStore.matchProject(windowTitle: "ProjectB", bundleId: "com.b", projects: projects)
+        #expect(result == nil)
+    }
+
+    @Test("matchProject returns nil for empty projects")
+    func emptyProjects() {
+        let result = ProjectStore.matchProject(windowTitle: "Anything", bundleId: "com.any", projects: [])
+        #expect(result == nil)
+    }
+
+    @Test("matchProject is case-insensitive")
+    func caseInsensitive() {
+        let projects = [
+            RecProject(name: "myapp", path: nil),
+        ]
+        let result = ProjectStore.matchProject(windowTitle: "MyApp - Editor", bundleId: nil, projects: projects)
+        #expect(result?.name == "myapp")
+    }
+}

package/src/native/Recordings/RecordingsTests/RealtimeTranscriptionTests.swift

@@ -0,0 +1,113 @@
+import Testing
+@testable import RecordingsLib
+
+// MARK: - RealtimeTranscriptionClient Event Parsing Tests
+
+struct RealtimeTranscriptionTests {
+    @Test("Model ID is set to latest gpt-4o-transcribe")
+    func modelID() {
+        #expect(RealtimeTranscriptionClient.modelID == "gpt-4o-transcribe")
+    }
+
+    @Test("Parses transcription delta events")
+    func parseDelta() {
+        let deltaJSON = """
+        {"type":"conversation.item.input_audio_transcription.delta","delta":"Hello "}
+        """
+        #expect(RealtimeTranscriptionClient.parseDeltaTestHelper(deltaJSON) == "Hello ")
+    }
+
+    @Test("Parses transcription completed event")
+    func parseCompleted() {
+        let completedJSON = """
+        {"type":"conversation.item.input_audio_transcription.completed","transcript":"Hello world"}
+        """
+        #expect(RealtimeTranscriptionClient.parseDeltaTestHelper(completedJSON) == "Hello world")
+    }
+
+    @Test("Returns nil for non-transcription events")
+    func ignoreOtherEvents() {
+        let sessionJSON = """
+        {"type":"session.created","session":{"id":"abc"}}
+        """
+        #expect(RealtimeTranscriptionClient.parseDeltaTestHelper(sessionJSON) == nil)
+    }
+
+    @Test("Returns nil for malformed JSON")
+    func malformedJSON() {
+        #expect(RealtimeTranscriptionClient.parseDeltaTestHelper("not json") == nil)
+    }
+
+    @Test("Returns nil for empty delta")
+    func emptyDelta() {
+        let emptyJSON = """
+        {"type":"conversation.item.input_audio_transcription.delta","delta":""}
+        """
+        // Empty string delta is still valid — client should handle it
+        #expect(RealtimeTranscriptionClient.parseDeltaTestHelper(emptyJSON) == "")
+    }
+
+    @Test("Detects error events")
+    func detectError() {
+        let errorJSON = """
+        {"type":"error","error":{"message":"Invalid API key","code":401}}
+        """
+        #expect(RealtimeTranscriptionClient.isSessionErrorTestHelper(errorJSON) == true)
+    }
+
+    @Test("Does not flag normal events as errors")
+    func noFalsePositives() {
+        #expect(RealtimeTranscriptionClient.isSessionErrorTestHelper(
+            "{\"type\":\"conversation.item.input_audio_transcription.delta\"}"
+        ) == false)
+    }
+
+    @Test("Parse error message from error event")
+    func parseErrorMessage() {
+        let errorJSON = """
+        {"type":"error","error":{"message":"Model not found","code":404}}
+        """
+        #expect(RealtimeTranscriptionClient.parseErrorTestHelper(errorJSON) == "Model not found")
+    }
+
+    @Test("Builds strict verbatim prompt with vocabulary context")
+    func buildPrompt() {
+        let prompt = RealtimeTranscriptionClient.buildPromptTestHelper("Alumia, Takumi")
+        #expect(prompt.contains("verbatim"))
+        #expect(prompt.contains("Do not summarize"))
+        #expect(prompt.contains("vocabulary context"))
+        #expect(prompt.contains("Alumia"))
+    }
+
+    @Test("Builds realtime transcription session update event")
+    func buildSessionUpdateEvent() {
+        let event = RealtimeTranscriptionClient.sessionUpdateTestHelper(prompt: "Use Alumia as vocabulary", language: "en")
+        #expect(event["type"] as? String == "session.update")
+
+        let session = event["session"] as? [String: Any]
+        #expect(session?["type"] as? String == "transcription")
+
+        let audio = session?["audio"] as? [String: Any]
+        let input = audio?["input"] as? [String: Any]
+        let format = input?["format"] as? [String: Any]
+        #expect(format?["type"] as? String == "audio/pcm")
+        #expect(format?["rate"] as? Int == 24_000)
+
+        let transcription = input?["transcription"] as? [String: Any]
+        #expect(transcription?["model"] as? String == "gpt-4o-transcribe")
+        #expect(transcription?["prompt"] as? String == "Use Alumia as vocabulary")
+        #expect(transcription?["language"] as? String == "en")
+
+        let turnDetection = input?["turn_detection"] as? [String: Any]
+        #expect(turnDetection?["type"] as? String == "server_vad")
+
+        let include = session?["include"] as? [String]
+        #expect(include?.contains("item.input_audio_transcription.logprobs") == true)
+    }
+
+    @Test("Joins transcript parts without dropping spoken text")
+    func joinParts() {
+        let text = RealtimeTranscriptionClient.joinTranscriptPartsTestHelper(["Hello", "world.", " Next"])
+        #expect(text == "Hello world. Next")
+    }
+}

package/src/native/Recordings/build.sh

@@ -1,4 +1,4 @@
-#!/bin/bash
+#!/usr/bin/env bash
 # Build Recordings.app for macOS 26
 # Usage: ./build.sh [debug|release]
 
@@ -9,7 +9,7 @@ SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
 cd "$SCRIPT_DIR"
 
 echo "Building Recordings.app ($MODE)..."
-swift build -c "$MODE"
+swift build -c "$MODE" --product App
 
 # Create .app bundle
 BUILD_DIR=".build/$MODE"
@@ -21,14 +21,14 @@ rm -rf "$APP_DIR"
 mkdir -p "$MACOS"
 
 # Copy binary
-cp "$BUILD_DIR/Recordings" "$MACOS/Recordings"
+cp "$BUILD_DIR/App" "$MACOS/Recordings"
 
 # Copy Info.plist
-cp Recordings/Info.plist "$CONTENTS/Info.plist"
+cp RecordingsLib/Info.plist "$CONTENTS/Info.plist"
 
 # Copy entitlements (for codesigning)
-if [ -f Recordings/Recordings.entitlements ]; then
-    codesign --force --sign - --entitlements Recordings/Recordings.entitlements "$APP_DIR" 2>/dev/null || true
+if [ -f RecordingsLib/Recordings.entitlements ]; then
+    codesign --force --sign - --entitlements RecordingsLib/Recordings.entitlements "$APP_DIR" 2>/dev/null || true
 fi
 
 echo "✓ Built $APP_DIR"