agent-cli 0.95.6__tar.gz → 0.95.8__tar.gz

agent_cli-0.95.8/Casks/agent-cli.rb

@@ -0,0 +1,29 @@
+cask "agent-cli" do
+  version "0.95.7"
+  sha256 "9db4a8d9f44765e1197d687a46e4cde041ada2d5284e6a22324c706d2a40848e"
+
+  url "https://github.com/basnijholt/agent-cli/releases/download/v#{version}/AgentCLI.dmg"
+  name "Agent CLI"
+  desc "Local-first AI voice and text tools with menu bar integration"
+  homepage "https://github.com/basnijholt/agent-cli"
+
+  livecheck do
+    url :url
+    strategy :github_latest
+  end
+
+  depends_on arch: :arm64
+  depends_on macos: :ventura
+
+  app "AgentCLI.app"
+
+  uninstall launchctl: "com.agent_cli.whisper",
+            quit:      "lt.nijho.agent-cli.menubar"
+
+  zap trash: [
+    "~/Library/Application Support/AgentCLI",
+    "~/Library/LaunchAgents/com.agent_cli.whisper.plist",
+    "~/Library/Logs/agent-cli-whisper",
+    "~/Library/Preferences/lt.nijho.agent-cli.menubar.plist",
+  ]
+end

{agent_cli-0.95.6 → agent_cli-0.95.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agent-cli
-Version: 0.95.6
+Version: 0.95.8
 Summary: A suite of AI-powered command-line tools for text correction, audio transcription, and voice assistance.
 Project-URL: Homepage, https://github.com/basnijholt/agent-cli
 Author-email: Bas Nijholt <bas@nijho.lt>

{agent_cli-0.95.6 → agent_cli-0.95.8}/macos/AgentCLI/Sources/AgentCLI/AgentCLIApp.swift

@@ -167,7 +167,7 @@ struct AgentCLIApp: App {
                 Label("Quit", systemImage: "power")
             }
         } label: {
-            AgentCLIMenuBarIcon(isRecording: runner.isRecording)
+            AgentCLIMenuBarIcon(state: runner.menuBarIconState)
         }
         .menuBarExtraStyle(.menu)
 

{agent_cli-0.95.6 → agent_cli-0.95.8}/macos/AgentCLI/Sources/AgentCLI/AgentCommand.swift

@@ -1,9 +1,13 @@
 import Foundation
 
-enum AgentBootstrapRequirement: Equatable {
-    case cliRuntime
-    case transcription
-    case transcriptionModel
+private extension String {
+    var isVisiblyBlank: Bool {
+        unicodeScalars.allSatisfy { scalar in
+            CharacterSet.whitespacesAndNewlines.contains(scalar)
+                || scalar.properties.generalCategory == .format
+                || scalar.properties.generalCategory == .control
+        }
+    }
 }
 
 struct AgentCommand {
@@ -46,7 +50,7 @@ struct AgentCommand {
         guard appliesTranscriptionExtraInstructions else { return arguments }
 
         let trimmedInstructions = extraInstructions?.trimmingCharacters(in: .whitespacesAndNewlines) ?? ""
-        guard !trimmedInstructions.isEmpty else { return arguments }
+        guard !trimmedInstructions.isVisiblyBlank else { return arguments }
 
         return arguments + ["--extra-instructions", trimmedInstructions]
     }

{agent_cli-0.95.6 → agent_cli-0.95.8}/macos/AgentCLI/Sources/AgentCLI/AgentCommandRunner.swift

@@ -19,8 +19,6 @@ private enum HoldTranscriptionState {
     }
 }
 
-typealias AgentBootstrap = @Sendable (AgentBootstrapRequirement, Bool) -> CommandResult
-
 @MainActor
 final class AgentCommandRunner: ObservableObject {
     static let shared = AgentCommandRunner()
@@ -29,10 +27,15 @@ final class AgentCommandRunner: ObservableObject {
     @Published var lastOutput = ""
     @Published private(set) var hasLastError = false
     @Published private(set) var isRecording = false
+    @Published private(set) var bootstrapPhase: BootstrapPhase = .idle
     @Published private var activeCommandCount = 0
+    @Published private var bootstrapAnimationTick = 0
+    @Published private var bootstrapElapsedSeconds = 0
     private var recordingIndicator = RecordingIndicatorController()
     private let pasteController: TranscriptPasteController
     private let bootstrap: AgentBootstrap
+    private var bootstrapAnimationTimer: Timer?
+    private var bootstrapPhaseStartedAt: Date?
     private var pendingStopRecordingCommands: Set<String> = []
     private var holdTranscriptionState: HoldTranscriptionState = .idle
     private var holdToTranscribePasteTarget: FocusedTextTarget?
@@ -47,6 +50,12 @@ final class AgentCommandRunner: ObservableObject {
         if isRecording {
             return "Recording"
         }
+        if bootstrapPhase.isPreparing {
+            return bootstrapPhase.statusMessage(
+                animationTick: bootstrapAnimationTick,
+                elapsedSeconds: bootstrapElapsedSeconds
+            )
+        }
         if holdTranscriptionState.isFinishing {
             return "Transcribing..."
         }
@@ -56,10 +65,20 @@ final class AgentCommandRunner: ObservableObject {
         return Self.compactMenuStatus(statusMessage)
     }
 
+    var menuBarIconState: MenuBarIconState {
+        if isRecording {
+            return .recording
+        }
+        if bootstrapPhase.isPreparing {
+            return .preparing
+        }
+        return .idle
+    }
+
     init(
         pasteController: TranscriptPasteController = TranscriptPasteController(),
-        bootstrap: @escaping AgentBootstrap = { requirement, force in
-            AgentRuntime.shared.ensureReady(for: requirement, force: force)
+        bootstrap: @escaping AgentBootstrap = { requirement, force, progress in
+            AgentRuntime.shared.ensureReady(for: requirement, force: force, progress: progress)
         }
     ) {
         self.pasteController = pasteController
@@ -82,13 +101,12 @@ final class AgentCommandRunner: ObservableObject {
         hasStartedTranscriptionWarmUp = true
 
         activeCommandCount += 1
-        if statusMessage == "Ready" {
-            statusMessage = "Preparing voice service..."
-        }
+        reportBootstrapPhase(.checkingRuntime)
 
         let bootstrap = self.bootstrap
+        let reportBootstrapPhase = makeBootstrapProgressReporter()
         DispatchQueue.global(qos: .utility).async {
-            let result = bootstrap(.transcriptionModel, false)
+            let result = bootstrap(.transcriptionModel, false, reportBootstrapPhase)
 
             Task { @MainActor in
                 self.activeCommandCount = max(0, self.activeCommandCount - 1)
@@ -97,12 +115,11 @@ final class AgentCommandRunner: ObservableObject {
                 }
 
                 if result.exitCode == 0 {
-                    if self.statusMessage == "Preparing voice service..." {
-                        self.statusMessage = "Ready"
-                    }
+                    self.reportBootstrapPhase(.idle)
                     return
                 }
 
+                self.reportBootstrapPhase(.failed)
                 self.recordFailure(title: "Startup Voice Service Warm-Up", result: result)
                 self.statusMessage = result.output.isEmpty
                     ? "Voice service warm-up failed with exit code \(result.exitCode)"
@@ -111,6 +128,57 @@ final class AgentCommandRunner: ObservableObject {
         }
     }
 
+    private func reportBootstrapPhase(_ phase: BootstrapPhase) {
+        let wasPreparing = bootstrapPhase.isPreparing
+        let phaseChanged = bootstrapPhase != phase
+        bootstrapPhase = phase
+        if phase.isPreparing {
+            if !wasPreparing || phaseChanged {
+                bootstrapAnimationTick = 0
+                bootstrapElapsedSeconds = 0
+                bootstrapPhaseStartedAt = Date()
+            }
+            startBootstrapAnimationTimer()
+        } else {
+            stopBootstrapAnimationTimer()
+        }
+    }
+
+    private func makeBootstrapProgressReporter() -> AgentBootstrapProgress {
+        { [weak self] phase in
+            Task { @MainActor in
+                self?.reportBootstrapPhase(phase)
+            }
+        }
+    }
+
+    private func startBootstrapAnimationTimer() {
+        guard bootstrapAnimationTimer == nil else { return }
+        let timer = Timer(timeInterval: 0.8, repeats: true) { [weak self] _ in
+            Task { @MainActor in
+                guard let self else { return }
+                guard self.bootstrapPhase.isPreparing else {
+                    self.stopBootstrapAnimationTimer()
+                    return
+                }
+                self.bootstrapAnimationTick = (self.bootstrapAnimationTick + 1) % 3
+                if let startedAt = self.bootstrapPhaseStartedAt {
+                    self.bootstrapElapsedSeconds = max(0, Int(Date().timeIntervalSince(startedAt)))
+                }
+            }
+        }
+        RunLoop.main.add(timer, forMode: .common)
+        bootstrapAnimationTimer = timer
+    }
+
+    private func stopBootstrapAnimationTimer() {
+        bootstrapAnimationTimer?.invalidate()
+        bootstrapAnimationTimer = nil
+        bootstrapAnimationTick = 0
+        bootstrapElapsedSeconds = 0
+        bootstrapPhaseStartedAt = nil
+    }
+
     @discardableResult
     func beginHoldToTranscribe() -> Bool {
         guard holdTranscriptionState == .idle else {
@@ -171,19 +239,23 @@ final class AgentCommandRunner: ObservableObject {
         }
 
         activeCommandCount += 1
-        statusMessage = isStopRequest
-            ? "Stopping \(command.title)..."
-            : "Running \(command.title)..."
+        if !self.bootstrapPhase.isPreparing {
+            statusMessage = isStopRequest
+                ? "Stopping \(command.title)..."
+                : "Running \(command.title)..."
+        }
 
         let bootstrap = self.bootstrap
+        let reportBootstrapPhase = makeBootstrapProgressReporter()
         let commandArguments = command.resolvedArguments(extraInstructions: TranscriptionSettings.extraInstructions)
         DispatchQueue.global(qos: .userInitiated).async {
-            let bootstrapResult = bootstrap(command.bootstrapRequirement, command.forceBootstrap)
+            let bootstrapResult = bootstrap(command.bootstrapRequirement, command.forceBootstrap, reportBootstrapPhase)
             guard bootstrapResult.exitCode == 0 else {
                 let message = Self.statusMessage(for: command, result: bootstrapResult)
                 let notificationTitle = Self.notificationTitle(for: command, result: bootstrapResult)
                 let notificationBody = Self.notificationBody(for: command, result: bootstrapResult, statusMessage: message)
                 Task { @MainActor in
+                    self.reportBootstrapPhase(.failed)
                     if isStopRequest {
                         self.clearStopRequested(for: command)
                     }
@@ -200,6 +272,10 @@ final class AgentCommandRunner: ObservableObject {
                 return
             }
 
+            Task { @MainActor in
+                self.reportBootstrapPhase(.idle)
+            }
+
             if shouldStartRecording {
                 Task { @MainActor in
                     if self.beginRecordingIndicator(for: command) {
@@ -261,14 +337,17 @@ final class AgentCommandRunner: ObservableObject {
         statusMessage = "Stopping Toggle Transcription..."
 
         let bootstrap = self.bootstrap
+        let reportBootstrapPhase = makeBootstrapProgressReporter()
         DispatchQueue.global(qos: .userInitiated).async {
             let bootstrapResult = bootstrap(
                 AgentCommand.stopTranscription.bootstrapRequirement,
-                AgentCommand.stopTranscription.forceBootstrap
+                AgentCommand.stopTranscription.forceBootstrap,
+                reportBootstrapPhase
             )
             guard bootstrapResult.exitCode == 0 else {
                 let message = Self.statusMessage(for: AgentCommand.stopTranscription, result: bootstrapResult)
                 Task { @MainActor in
+                    self.reportBootstrapPhase(.failed)
                     self.holdTranscriptionState = .idle
                     self.lastOutput = bootstrapResult.output
                     self.recordFailure(command: AgentCommand.stopTranscription, result: bootstrapResult)
@@ -281,6 +360,10 @@ final class AgentCommandRunner: ObservableObject {
                 return
             }
 
+            Task { @MainActor in
+                self.reportBootstrapPhase(.idle)
+            }
+
             let result = AgentRuntime.shared.runAgentCLI(arguments: AgentCommand.stopTranscription.arguments)
 
             Task { @MainActor in

{agent_cli-0.95.6 → agent_cli-0.95.8}/macos/AgentCLI/Sources/AgentCLI/AgentRuntime.swift

@@ -170,7 +170,10 @@ struct AgentRuntime {
         exit(0)
     }
 
-    func ensureInstalled(force: Bool = false) -> CommandResult {
+    func ensureInstalled(
+        force: Bool = false,
+        progress: AgentBootstrapProgress = { _ in }
+    ) -> CommandResult {
         let mode = runtimeMode
         do {
             try prepareDirectories(for: mode)
@@ -179,6 +182,7 @@ struct AgentRuntime {
         }
 
         if mode == .userInstalled {
+            progress(.checkingRuntime)
             return ensureUserInstalledCLIAvailable()
         }
 
@@ -188,6 +192,7 @@ struct AgentRuntime {
             return CommandResult(exitCode: 0, output: "")
         }
 
+        progress(.installingRuntime)
         guard fileManager.isExecutableFile(atPath: bundledUVURL.path) else {
             return CommandResult(
                 exitCode: 127,
@@ -243,36 +248,54 @@ struct AgentRuntime {
         "packageSource=\(agentCLIPackageSource)\ninstallRequirement=\(agentCLIInstallRequirement)\n"
     }
 
-    func ensureReady(for requirement: AgentBootstrapRequirement, force: Bool = false) -> CommandResult {
+    func ensureReady(
+        for requirement: AgentBootstrapRequirement,
+        force: Bool = false,
+        progress: AgentBootstrapProgress = { _ in }
+    ) -> CommandResult {
         Self.bootstrapQueue.sync {
-            ensureReadyUnsynchronized(for: requirement, force: force)
+            ensureReadyUnsynchronized(for: requirement, force: force, progress: progress)
         }
     }
 
-    private func ensureReadyUnsynchronized(for requirement: AgentBootstrapRequirement, force: Bool = false) -> CommandResult {
+    private func ensureReadyUnsynchronized(
+        for requirement: AgentBootstrapRequirement,
+        force: Bool = false,
+        progress: AgentBootstrapProgress
+    ) -> CommandResult {
         switch requirement {
         case .cliRuntime:
-            return ensureInstalled(force: force)
+            return ensureInstalled(force: force, progress: progress)
         case .transcription:
-            let installResult = ensureInstalled(force: force)
+            let installResult = ensureInstalled(force: force, progress: progress)
             guard installResult.exitCode == 0 else {
                 return installResult
             }
-            return ensureWhisperDaemon(force: force)
+            return ensureWhisperDaemon(force: force, progress: progress)
         case .transcriptionModel:
-            let daemonResult = ensureReadyUnsynchronized(for: .transcription, force: force)
+            let daemonResult = ensureReadyUnsynchronized(
+                for: .transcription,
+                force: force,
+                progress: progress
+            )
             guard daemonResult.exitCode == 0 else {
                 return daemonResult
             }
+            progress(.warmingWhisperModel)
             return warmUpWhisperModel()
         }
     }
 
-    private func ensureWhisperDaemon(force: Bool = false) -> CommandResult {
+    private func ensureWhisperDaemon(
+        force: Bool = false,
+        progress: AgentBootstrapProgress
+    ) -> CommandResult {
         if !force, (try? String(contentsOf: whisperDaemonMarkerURL)) == whisperDaemonMarkerContents {
+            progress(.waitingForVoiceService)
             return waitForWhisperDaemonReady()
         }
 
+        progress(.installingVoiceService)
         let result = runAgentCLI(arguments: ["daemon", "install", "whisper", "-y"])
         guard result.exitCode == 0 else {
             return result
@@ -283,6 +306,7 @@ struct AgentRuntime {
             atomically: true,
             encoding: .utf8
         )
+        progress(.waitingForVoiceService)
         return waitForWhisperDaemonReady()
     }
 

agent_cli-0.95.8/macos/AgentCLI/Sources/AgentCLI/BootstrapState.swift

@@ -0,0 +1,58 @@
+import Foundation
+
+enum AgentBootstrapRequirement: Equatable {
+    case cliRuntime
+    case transcription
+    case transcriptionModel
+}
+
+enum BootstrapPhase: Equatable {
+    case idle
+    case checkingRuntime
+    case installingRuntime
+    case installingVoiceService
+    case waitingForVoiceService
+    case warmingWhisperModel
+    case failed
+
+    var isPreparing: Bool {
+        switch self {
+        case .idle, .failed:
+            return false
+        case .checkingRuntime, .installingRuntime, .installingVoiceService, .waitingForVoiceService, .warmingWhisperModel:
+            return true
+        }
+    }
+
+    var statusMessage: String {
+        switch self {
+        case .idle:
+            return "Ready"
+        case .checkingRuntime:
+            return "Checking CLI runtime..."
+        case .installingRuntime:
+            return "Installing CLI runtime..."
+        case .installingVoiceService:
+            return "Installing voice service..."
+        case .waitingForVoiceService:
+            return "Waiting for voice service..."
+        case .warmingWhisperModel:
+            return "Warming Whisper model..."
+        case .failed:
+            return "Voice service warm-up failed"
+        }
+    }
+
+    func statusMessage(animationTick: Int, elapsedSeconds: Int) -> String {
+        switch self {
+        case .waitingForVoiceService:
+            let periodCount = (animationTick % 3) + 1
+            return "Waiting for voice service\(String(repeating: ".", count: periodCount)) (\(elapsedSeconds)s)"
+        case .idle, .checkingRuntime, .installingRuntime, .installingVoiceService, .warmingWhisperModel, .failed:
+            return statusMessage
+        }
+    }
+}
+
+typealias AgentBootstrapProgress = (BootstrapPhase) -> Void
+typealias AgentBootstrap = (AgentBootstrapRequirement, Bool, @escaping AgentBootstrapProgress) -> CommandResult

agent_cli-0.95.8/macos/AgentCLI/Sources/AgentCLI/MenuBarIcon.swift

@@ -0,0 +1,111 @@
+import AppKit
+import Foundation
+import SwiftUI
+
+enum MenuBarIconState: Equatable {
+    case idle
+    case preparing
+    case recording
+}
+
+struct AgentCLIMenuBarIcon: View {
+    let state: MenuBarIconState
+
+    var body: some View {
+        if let image = Self.logoImage(state: state) {
+            Image(nsImage: image)
+                .resizable()
+                .aspectRatio(contentMode: .fit)
+                .frame(width: 22, height: 18)
+                .id(state)
+                .accessibilityLabel(accessibilityLabel)
+        } else {
+            Image(systemName: fallbackSystemImage)
+                .id(state)
+                .accessibilityLabel(accessibilityLabel)
+        }
+    }
+
+    private var accessibilityLabel: Text {
+        switch state {
+        case .idle:
+            return Text("Agent CLI")
+        case .preparing:
+            return Text("Agent CLI preparing")
+        case .recording:
+            return Text("Agent CLI recording")
+        }
+    }
+
+    private var fallbackSystemImage: String {
+        switch state {
+        case .idle:
+            return "person.crop.circle"
+        case .preparing:
+            return "arrow.triangle.2.circlepath.circle.fill"
+        case .recording:
+            return "record.circle.fill"
+        }
+    }
+
+    private static func logoImage(state: MenuBarIconState) -> NSImage? {
+        switch state {
+        case .idle:
+            return idleLogoImage
+        case .preparing:
+            return preparingLogoImage
+        case .recording:
+            return recordingLogoImage
+        }
+    }
+
+    private static let idleLogoImage: NSImage? = {
+        guard let url = Bundle.main.url(forResource: "logo-avatar", withExtension: "svg"),
+              let image = NSImage(contentsOf: url)
+        else {
+            return nil
+        }
+        image.isTemplate = true
+        image.size = NSSize(width: 18, height: 18)
+        return image
+    }()
+
+    private static let recordingLogoImage: NSImage? = makeRecordingLogoImage()
+    private static let preparingLogoImage: NSImage? = makePreparingLogoImage()
+
+    private static func makeRecordingLogoImage() -> NSImage? {
+        makeBadgedLogoImage(badgeColor: .systemRed, badgeDiameter: 7)
+    }
+
+    private static func makePreparingLogoImage() -> NSImage? {
+        makeBadgedLogoImage(badgeColor: .controlAccentColor, badgeDiameter: 7)
+    }
+
+    private static func makeBadgedLogoImage(badgeColor: NSColor, badgeDiameter: CGFloat) -> NSImage? {
+        guard let url = Bundle.main.url(forResource: "logo-avatar", withExtension: "svg"),
+              let avatar = NSImage(contentsOf: url)
+        else {
+            return nil
+        }
+
+        avatar.size = NSSize(width: 18, height: 18)
+
+        let image = NSImage(size: NSSize(width: 22, height: 18))
+        image.lockFocus()
+        avatar.draw(
+            in: NSRect(x: 0, y: 0, width: 18, height: 18),
+            from: .zero,
+            operation: .sourceOver,
+            fraction: 1
+        )
+
+        NSColor.white.setFill()
+        NSBezierPath(ovalIn: NSRect(x: 12.5, y: 0.5, width: 10, height: 10)).fill()
+        badgeColor.setFill()
+        NSBezierPath(ovalIn: NSRect(x: 14, y: 2, width: badgeDiameter, height: badgeDiameter)).fill()
+        image.unlockFocus()
+
+        image.isTemplate = false
+        return image
+    }
+}

{agent_cli-0.95.6 → agent_cli-0.95.8}/macos/AgentCLI/Sources/AgentCLI/RecordingIndicatorController.swift

@@ -3,6 +3,16 @@ import Foundation
 final class RecordingIndicatorController {
     private var recordingCommandCount = 0
     private var activeRecordingCommands: [String: Int] = [:]
+    private let defaults: UserDefaults
+    private let audioCuePlayer: RecordingCuePlaying
+
+    init(
+        defaults: UserDefaults = .standard,
+        audioCuePlayer: RecordingCuePlaying = NativeRecordingCuePlayer.shared
+    ) {
+        self.defaults = defaults
+        self.audioCuePlayer = audioCuePlayer
+    }
 
     var isRecording: Bool {
         recordingCommandCount > 0
@@ -13,12 +23,17 @@ final class RecordingIndicatorController {
     }
 
     func begin(for command: AgentCommand) {
+        let wasRecording = isRecording
         activeRecordingCommands[command.identifier, default: 0] += 1
         recordingCommandCount += 1
+        if !wasRecording {
+            play(.startedRecording)
+        }
         VoiceLevelOverlayController.shared.show()
     }
 
     func end(for command: AgentCommand) {
+        let wasRecording = isRecording
         let activeCommandCount = max(0, activeRecordingCommands[command.identifier, default: 0] - 1)
         if activeCommandCount > 0 {
             activeRecordingCommands[command.identifier] = activeCommandCount
@@ -26,8 +41,14 @@ final class RecordingIndicatorController {
             activeRecordingCommands.removeValue(forKey: command.identifier)
         }
         recordingCommandCount = max(0, recordingCommandCount - 1)
-        if !isRecording {
+        if wasRecording && !isRecording {
+            play(.finishedRecording)
             VoiceLevelOverlayController.shared.hide()
         }
     }
+
+    private func play(_ event: RecordingSoundEvent) {
+        guard RecordingSoundSettings.isEnabled(defaults: defaults) else { return }
+        audioCuePlayer.play(event)
+    }
 }

agent_cli-0.95.8/macos/AgentCLI/Sources/AgentCLI/RecordingSoundSettings.swift

@@ -0,0 +1,54 @@
+import AppKit
+import Foundation
+
+enum RecordingSoundSettings {
+    static let enabledKey = "recordingNotificationSoundsEnabled"
+
+    static func isEnabled(defaults: UserDefaults = .standard) -> Bool {
+        defaults.bool(forKey: enabledKey)
+    }
+}
+
+enum RecordingSoundEvent: Hashable {
+    case startedRecording
+    case finishedRecording
+
+    var cueName: NSSound.Name {
+        switch self {
+        case .startedRecording:
+            return NSSound.Name("Frog")
+        case .finishedRecording:
+            return NSSound.Name("Funk")
+        }
+    }
+}
+
+protocol RecordingCuePlaying: AnyObject {
+    func play(_ event: RecordingSoundEvent)
+}
+
+final class NativeRecordingCuePlayer: RecordingCuePlaying {
+    static let shared = NativeRecordingCuePlayer()
+
+    private var sounds: [RecordingSoundEvent: NSSound] = [:]
+
+    private init() {}
+
+    func play(_ event: RecordingSoundEvent) {
+        guard let sound = sound(for: event) else { return }
+        sound.stop()
+        sound.currentTime = 0
+        sound.play()
+    }
+
+    private func sound(for event: RecordingSoundEvent) -> NSSound? {
+        if let sound = sounds[event] {
+            return sound
+        }
+        guard let sound = NSSound(named: event.cueName) else {
+            return nil
+        }
+        sounds[event] = sound
+        return sound
+    }
+}