@hasna/recordings 0.1.11 → 0.1.13

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

@@ -1,12 +1,19 @@
 import SwiftUI
 import KeyboardShortcuts
 
-struct SettingsView: View {
-    @ObservedObject var engine: RecordingEngine
-    @ObservedObject var shortcuts: VoiceShortcuts
-    @ObservedObject var projectStore: ProjectStore
+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
+    }
 
-    var body: some View {
+    public var body: some View {
         TabView {
             generalTab.tabItem { Label("General", systemImage: "gear") }
             projectsTab.tabItem { Label("Projects", systemImage: "folder") }
@@ -19,6 +26,13 @@ struct SettingsView: View {
 
     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")

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/NativeAppDiagnosticsTests.swift

@@ -0,0 +1,23 @@
+import Foundation
+import Testing
+@testable import RecordingsLib
+
+struct NativeAppDiagnosticsTests {
+    @Test("Native app log writes to recordings log file")
+    func logWritesFile() throws {
+        let home = try makeHome()
+
+        NativeAppLog.write("diagnostic-test", homePath: home)
+
+        let path = "\(home)/.hasna/recordings/Recordings.log"
+        let text = try String(contentsOfFile: path, encoding: .utf8)
+        #expect(text.contains("diagnostic-test"))
+    }
+
+    private func makeHome() throws -> String {
+        let url = FileManager.default.temporaryDirectory
+            .appendingPathComponent("recordings-diagnostics-tests-\(UUID().uuidString)")
+        try FileManager.default.createDirectory(at: url, withIntermediateDirectories: true)
+        return url.path
+    }
+}

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"

package/.takumi/settings.local.json

@@ -1,7 +0,0 @@
-{
-  "permissions": {
-    "allow": [
-      "Bash(ssh apple03:*)"
-    ]
-  }
-}