agent-cli 0.96.2__tar.gz → 0.96.4__tar.gz

{agent_cli-0.96.2 → agent_cli-0.96.4}/Casks/agent-cli.rb

@@ -1,6 +1,6 @@
 cask "agent-cli" do
-  version "0.96.1"
-  sha256 "eef32008aa3d60a114eac824bc32c12385de07c7656bae5edcde24487fc3d72d"
+  version "0.96.3"
+  sha256 "6346b0f335005094152ceb987b5e7d44fb08d817a07ca3433a05fba3fa85ec2f"
 
   url "https://github.com/basnijholt/agent-cli/releases/download/v#{version}/AgentCLI.dmg"
   name "Agent CLI"

{agent_cli-0.96.2 → agent_cli-0.96.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agent-cli
-Version: 0.96.2
+Version: 0.96.4
 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.96.2 → agent_cli-0.96.4}/macos/AgentCLI/Sources/AgentCLI/AgentCommand.swift

@@ -55,6 +55,10 @@ struct AgentCommand {
         return arguments + ["--extra-instructions", trimmedInstructions]
     }
 
+    var menuActivityTitle: String {
+        title
+    }
+
     static let toggleTranscription = AgentCommand(
         identifier: "transcribe",
         title: "Toggle Transcription",

{agent_cli-0.96.2 → agent_cli-0.96.4}/macos/AgentCLI/Sources/AgentCLI/AgentCommandRunner.swift

@@ -31,7 +31,7 @@ final class AgentCommandRunner: ObservableObject {
     private var recordingIndicator = RecordingIndicatorController()
     private let pasteController: TranscriptPasteController
     private let bootstrap: AgentBootstrap
-    private var bootstrapPhaseStartedAt: Date?
+    private var activityTracker = MenuActivityTracker()
     private var pendingStopRecordingCommands: Set<String> = []
     private var holdTranscriptionState: HoldTranscriptionState = .idle
     private var holdToTranscribePasteTarget: FocusedTextTarget?
@@ -43,22 +43,24 @@ final class AgentCommandRunner: ObservableObject {
     }
 
     var menuStatusMessage: String {
-        if isRecording {
-            return "Recording"
-        }
-        if bootstrapPhase.isPreparing {
-            return bootstrapPhase.statusMessage(
-                animationTick: bootstrapAnimationTick(now: Date()),
-                elapsedSeconds: bootstrapElapsedSeconds(now: Date())
-            )
-        }
-        if holdTranscriptionState.isFinishing {
-            return "Transcribing..."
-        }
+        menuActivityStatus.message
+    }
+
+    var menuActivityStatus: MenuActivityStatus {
+        menuActivityStatus(now: Date())
+    }
+
+    func menuActivityStatus(now: Date) -> MenuActivityStatus {
         if hasLastError && statusMessage.localizedCaseInsensitiveContains("failed") {
-            return "Last command failed"
+            return activityTracker.status(
+                now: now,
+                fallback: MenuActivityStatus.inactive(message: "Last command failed")
+            )
         }
-        return Self.compactMenuStatus(statusMessage)
+        return activityTracker.status(
+            now: now,
+            fallback: MenuActivityStatus.completed(title: Self.compactMenuStatus(statusMessage))
+        )
     }
 
     var menuBarIconState: MenuBarIconState {
@@ -125,10 +127,10 @@ final class AgentCommandRunner: ObservableObject {
         bootstrapPhase = phase
         if phase.isPreparing {
             if !wasPreparing || phaseChanged {
-                bootstrapPhaseStartedAt = Date()
+                activityTracker.beginBootstrap(title: phase.activityTitle)
             }
         } else {
-            bootstrapPhaseStartedAt = nil
+            activityTracker.finishBootstrap()
         }
     }
 
@@ -140,15 +142,6 @@ final class AgentCommandRunner: ObservableObject {
         }
     }
 
-    private func bootstrapAnimationTick(now: Date) -> Int {
-        bootstrapElapsedSeconds(now: now) % 4
-    }
-
-    private func bootstrapElapsedSeconds(now: Date) -> Int {
-        guard let startedAt = bootstrapPhaseStartedAt else { return 0 }
-        return max(0, Int(now.timeIntervalSince(startedAt)))
-    }
-
     @discardableResult
     func beginHoldToTranscribe() -> Bool {
         guard holdTranscriptionState == .idle else {
@@ -174,6 +167,7 @@ final class AgentCommandRunner: ObservableObject {
         holdTranscriptionState = .stopping
 
         let wasRecording = recordingIndicator.isRecordingCommand(.toggleTranscription)
+        beginTranscribingActivity()
         if wasRecording {
             endRecordingIndicator(for: .toggleTranscription)
             statusMessage = "Transcribing..."
@@ -206,9 +200,11 @@ final class AgentCommandRunner: ObservableObject {
 
         if isStopRequest {
             markStopRequested(for: command)
+            beginTranscribingActivity()
         }
 
         activeCommandCount += 1
+        beginCommandActivity(for: command)
         if !self.bootstrapPhase.isPreparing {
             statusMessage = isStopRequest
                 ? "Stopping \(command.title)..."
@@ -233,6 +229,8 @@ final class AgentCommandRunner: ObservableObject {
                         self.clearPasteAfterRecording(for: command)
                     }
                     self.clearHoldTranscriptionState(for: command)
+                    self.clearTranscribingActivityIfFinished()
+                    self.finishCommandActivity(for: command)
                     self.activeCommandCount = max(0, self.activeCommandCount - 1)
                     self.lastOutput = bootstrapResult.output
                     self.recordFailure(command: command, result: bootstrapResult)
@@ -272,7 +270,9 @@ final class AgentCommandRunner: ObservableObject {
                         }
                     }
                     self.clearPasteAfterRecording(for: command)
+                    self.clearTranscribingActivityIfFinished()
                 }
+                self.finishCommandActivity(for: command)
                 self.activeCommandCount = max(0, self.activeCommandCount - 1)
 
                 if isStopRequest && result.exitCode == 0 {
@@ -285,6 +285,7 @@ final class AgentCommandRunner: ObservableObject {
 
                 if isStopRequest {
                     self.clearStopRequested(for: command)
+                    self.clearTranscribingActivityIfFinished()
                 }
                 self.lastOutput = result.output
                 if result.exitCode != 0 {
@@ -319,6 +320,7 @@ final class AgentCommandRunner: ObservableObject {
                 Task { @MainActor in
                     self.reportBootstrapPhase(.failed)
                     self.holdTranscriptionState = .idle
+                    self.clearTranscribingActivityIfFinished()
                     self.lastOutput = bootstrapResult.output
                     self.recordFailure(command: AgentCommand.stopTranscription, result: bootstrapResult)
                     self.statusMessage = message
@@ -345,6 +347,7 @@ final class AgentCommandRunner: ObservableObject {
                 }
 
                 self.holdTranscriptionState = .idle
+                self.clearTranscribingActivityIfFinished()
                 let message = result.output.isEmpty
                     ? "Toggle Transcription stop failed with exit code \(result.exitCode)"
                     : "Toggle Transcription stop failed: \(result.output)"
@@ -368,6 +371,24 @@ final class AgentCommandRunner: ObservableObject {
         pendingStopRecordingCommands.remove(command.identifier)
     }
 
+    private func beginCommandActivity(for command: AgentCommand) {
+        activityTracker.beginCommand(identifier: command.identifier, title: command.menuActivityTitle)
+    }
+
+    private func finishCommandActivity(for command: AgentCommand) {
+        activityTracker.finishCommand(identifier: command.identifier)
+    }
+
+    private func beginTranscribingActivity() {
+        activityTracker.beginTranscribing()
+    }
+
+    private func clearTranscribingActivityIfFinished() {
+        if pendingStopRecordingCommands.isEmpty && !holdTranscriptionState.isFinishing {
+            activityTracker.finishTranscribing()
+        }
+    }
+
     private func shouldPasteAfterRecording(for command: AgentCommand) -> Bool {
         pasteAfterRecordingCommands.contains(command.identifier)
     }
@@ -390,14 +411,21 @@ final class AgentCommandRunner: ObservableObject {
             return false
         }
 
+        let wasRecording = isRecording
         recordingIndicator.begin(for: command)
         isRecording = recordingIndicator.isRecording
+        if !wasRecording && isRecording {
+            activityTracker.beginRecording()
+        }
         return true
     }
 
     private func endRecordingIndicator(for command: AgentCommand) {
         recordingIndicator.end(for: command)
         isRecording = recordingIndicator.isRecording
+        if !isRecording {
+            activityTracker.finishRecording()
+        }
     }
 
     func copyLastOutput() {

{agent_cli-0.96.2 → agent_cli-0.96.4}/macos/AgentCLI/Sources/AgentCLI/AgentRuntime.swift

@@ -12,6 +12,21 @@ private enum AgentCLIRuntimeMode: Equatable {
     }
 }
 
+private final class UserInstalledCLICheckCache {
+    private let lock = NSLock()
+    private var isAvailable = false
+
+    func hasSuccessfulCheck() -> Bool {
+        lock.withLock { isAvailable }
+    }
+
+    func update(with result: CommandResult) {
+        lock.withLock {
+            isAvailable = result.exitCode == 0
+        }
+    }
+}
+
 typealias AgentProcessRunner = (URL, [String], [String: String]) -> CommandResult
 typealias LocalhostConnector = (UInt16) -> Bool
 
@@ -42,6 +57,7 @@ struct AgentRuntime {
     private let userDefaults: UserDefaults
     private let processRunner: AgentProcessRunner
     private let localhostConnector: LocalhostConnector
+    private let userInstalledCLICheckCache: UserInstalledCLICheckCache
     private let whisperReadyTimeout: TimeInterval
     let appSupportURL: URL
     let bundledUVURL: URL
@@ -73,6 +89,7 @@ struct AgentRuntime {
         self.userDefaults = userDefaults
         self.processRunner = processRunner
         self.localhostConnector = localhostConnector
+        self.userInstalledCLICheckCache = UserInstalledCLICheckCache()
         self.whisperReadyTimeout = whisperReadyTimeout
 
         if let override = environment["AGENTCLI_APP_SUPPORT_DIR"], !override.isEmpty {
@@ -196,8 +213,13 @@ struct AgentRuntime {
         }
 
         if mode == .userInstalled {
+            if !force, userInstalledCLICheckCache.hasSuccessfulCheck() {
+                return CommandResult(exitCode: 0, output: "")
+            }
             progress(.checkingRuntime)
-            return ensureUserInstalledCLIAvailable()
+            let result = ensureUserInstalledCLIAvailable()
+            userInstalledCLICheckCache.update(with: result)
+            return result
         }
 
         if !force,

{agent_cli-0.96.2 → agent_cli-0.96.4}/macos/AgentCLI/Sources/AgentCLI/BootstrapState.swift

@@ -46,18 +46,17 @@ enum BootstrapPhase: Equatable {
     func statusMessage(animationTick: Int, elapsedSeconds: Int) -> String {
         switch self {
         case .checkingRuntime, .installingRuntime, .installingVoiceService, .waitingForVoiceService, .warmingWhisperModel:
-            let spinnerFrames = ["◐", "◓", "◑", "◒"]
-            let spinner = spinnerFrames[animationTick % spinnerFrames.count]
-            let minutes = elapsedSeconds / 60
-            let seconds = elapsedSeconds % 60
-            let elapsedTime = String(format: "%02d:%02d", minutes, seconds)
-            return "\(animatedStatusMessage) \(spinner) (\(elapsedTime))"
+            return MenuActivityStatus.active(
+                title: activityTitle,
+                animationTick: animationTick,
+                elapsedSeconds: elapsedSeconds
+            ).message
         case .idle, .failed:
             return statusMessage
         }
     }
 
-    private var animatedStatusMessage: String {
+    var activityTitle: String {
         switch self {
         case .checkingRuntime:
             return "Checking CLI runtime"

agent_cli-0.96.4/macos/AgentCLI/Sources/AgentCLI/MenuActivityStatus.swift

@@ -0,0 +1,29 @@
+import Foundation
+
+struct MenuActivityStatus: Equatable {
+    let message: String
+    let isActive: Bool
+
+    static func active(title: String, startedAt: Date, now: Date) -> MenuActivityStatus {
+        let elapsedSeconds = max(0, Int(now.timeIntervalSince(startedAt)))
+        return active(title: title, animationTick: elapsedSeconds % spinnerFrames.count, elapsedSeconds: elapsedSeconds)
+    }
+
+    static func active(title: String, animationTick: Int, elapsedSeconds: Int) -> MenuActivityStatus {
+        let spinner = spinnerFrames[animationTick % spinnerFrames.count]
+        let minutes = elapsedSeconds / 60
+        let seconds = elapsedSeconds % 60
+        let elapsedTime = String(format: "%02d:%02d", minutes, seconds)
+        return MenuActivityStatus(message: "\(title) \(spinner) (\(elapsedTime))", isActive: true)
+    }
+
+    static func completed(title: String) -> MenuActivityStatus {
+        MenuActivityStatus(message: "\(title) ✓", isActive: false)
+    }
+
+    static func inactive(message: String) -> MenuActivityStatus {
+        MenuActivityStatus(message: message, isActive: false)
+    }
+
+    private static let spinnerFrames = ["◐", "◓", "◑", "◒"]
+}

agent_cli-0.96.4/macos/AgentCLI/Sources/AgentCLI/MenuActivityStatusRow.swift

@@ -0,0 +1,26 @@
+import AppKit
+
+@MainActor
+final class MenuActivityStatusRow {
+    private let prefix: String
+    private let item: NSMenuItem
+    private let separator: NSMenuItem
+
+    init(prefix: String) {
+        self.prefix = prefix
+        item = NSMenuItem(title: "", action: nil, keyEquivalent: "")
+        item.isEnabled = false
+        separator = .separator()
+    }
+
+    func add(to menu: NSMenu) {
+        menu.addItem(item)
+        menu.addItem(separator)
+    }
+
+    func update(_ activityStatus: MenuActivityStatus) {
+        item.title = "\(prefix)\(activityStatus.message)"
+        item.isHidden = !activityStatus.isActive
+        separator.isHidden = !activityStatus.isActive
+    }
+}

agent_cli-0.96.4/macos/AgentCLI/Sources/AgentCLI/MenuActivityTracker.swift

@@ -0,0 +1,64 @@
+import Foundation
+
+struct MenuActivityTracker {
+    private struct Activity {
+        let title: String
+        let startedAt: Date
+    }
+
+    private var bootstrapActivity: Activity?
+    private var recordingActivity: Activity?
+    private var transcribingActivity: Activity?
+    private var commandActivities: [String: Activity] = [:]
+    private var commandActivityOrder: [String] = []
+
+    mutating func beginBootstrap(title: String, at startedAt: Date = Date()) {
+        bootstrapActivity = Activity(title: title, startedAt: startedAt)
+    }
+
+    mutating func finishBootstrap() {
+        bootstrapActivity = nil
+    }
+
+    mutating func beginRecording(at startedAt: Date = Date()) {
+        guard recordingActivity == nil else { return }
+        recordingActivity = Activity(title: "Recording", startedAt: startedAt)
+    }
+
+    mutating func finishRecording() {
+        recordingActivity = nil
+    }
+
+    mutating func beginTranscribing(at startedAt: Date = Date()) {
+        guard transcribingActivity == nil else { return }
+        transcribingActivity = Activity(title: "Transcribing", startedAt: startedAt)
+    }
+
+    mutating func finishTranscribing() {
+        transcribingActivity = nil
+    }
+
+    mutating func beginCommand(identifier: String, title: String, at startedAt: Date = Date()) {
+        if commandActivities[identifier] == nil {
+            commandActivityOrder.append(identifier)
+        }
+        commandActivities[identifier] = Activity(title: title, startedAt: startedAt)
+    }
+
+    mutating func finishCommand(identifier: String) {
+        commandActivities.removeValue(forKey: identifier)
+        commandActivityOrder.removeAll { $0 == identifier }
+    }
+
+    func status(now: Date = Date(), fallback: MenuActivityStatus) -> MenuActivityStatus {
+        guard let activity = currentActivity else { return fallback }
+        return MenuActivityStatus.active(title: activity.title, startedAt: activity.startedAt, now: now)
+    }
+
+    private var currentActivity: Activity? {
+        bootstrapActivity
+            ?? transcribingActivity
+            ?? recordingActivity
+            ?? commandActivityOrder.reversed().compactMap { commandActivities[$0] }.first
+    }
+}

{agent_cli-0.96.2 → agent_cli-0.96.4}/macos/AgentCLI/Sources/AgentCLI/StatusMenuController.swift

@@ -8,6 +8,7 @@ final class StatusMenuController: NSObject, NSMenuDelegate {
     private static let statusRefreshInterval: TimeInterval = 0.8
     private static let statusRefreshRunLoopModes: [RunLoop.Mode] = [.common, .eventTracking]
     private static let voiceStatusTitlePrefix = "Voice: "
+    private static let activityStatusTitlePrefix = "Status: "
 
     private let runner = AgentCommandRunner.shared
     private let appUpdater = AppUpdater.shared
@@ -19,6 +20,8 @@ final class StatusMenuController: NSObject, NSMenuDelegate {
     private let recentRecordingsMenu = NSMenu()
     private let troubleshootingMenu = NSMenu()
     private var voiceStatusItem: NSMenuItem?
+    private var recentActivityStatusRow: MenuActivityStatusRow?
+    private var troubleshootingActivityStatusRow: MenuActivityStatusRow?
     private var statusRefreshTimer: Timer?
 
     private override init() {
@@ -108,9 +111,12 @@ final class StatusMenuController: NSObject, NSMenuDelegate {
 
     private func rebuildRecentRecordingsMenu() {
         recentRecordingsMenu.removeAllItems()
+        recentActivityStatusRow = activityStatusRow(in: recentRecordingsMenu)
+
         let recentTranscriptions = RecentTranscriptionReader.recentTranscriptions()
         if recentTranscriptions.isEmpty {
             recentRecordingsMenu.addItem(disabledItem("No recent transcriptions"))
+            refreshDynamicStatus()
             return
         }
 
@@ -123,10 +129,13 @@ final class StatusMenuController: NSObject, NSMenuDelegate {
             item.representedObject = transcription.text
             recentRecordingsMenu.addItem(item)
         }
+        refreshDynamicStatus()
     }
 
     private func rebuildTroubleshootingMenu() {
         troubleshootingMenu.removeAllItems()
+        troubleshootingActivityStatusRow = activityStatusRow(in: troubleshootingMenu)
+
         troubleshootingMenu.addItem(actionItem(
             "Voice Service Status",
             symbolName: "waveform.path.ecg",
@@ -191,6 +200,7 @@ final class StatusMenuController: NSObject, NSMenuDelegate {
             symbolName: "arrow.counterclockwise",
             action: #selector(resetKeyboardShortcuts)
         ))
+        refreshDynamicStatus()
     }
 
     private func startStatusRefreshTimer() {
@@ -207,7 +217,9 @@ final class StatusMenuController: NSObject, NSMenuDelegate {
     }
 
     private func refreshDynamicStatus() {
-        voiceStatusItem?.title = "\(Self.voiceStatusTitlePrefix)\(runner.menuStatusMessage)"
+        let activityStatus = runner.menuActivityStatus
+        voiceStatusItem?.title = "\(Self.voiceStatusTitlePrefix)\(activityStatus.message)"
+        updateSubmenuActivityStatus(activityStatus)
         if let button = statusItem?.button {
             button.image = MenuBarIconImage.logoImage(state: runner.menuBarIconState)
             button.imagePosition = .imageOnly
@@ -215,6 +227,17 @@ final class StatusMenuController: NSObject, NSMenuDelegate {
         }
     }
 
+    private func updateSubmenuActivityStatus(_ activityStatus: MenuActivityStatus) {
+        recentActivityStatusRow?.update(activityStatus)
+        troubleshootingActivityStatusRow?.update(activityStatus)
+    }
+
+    private func activityStatusRow(in menu: NSMenu) -> MenuActivityStatusRow {
+        let row = MenuActivityStatusRow(prefix: Self.activityStatusTitlePrefix)
+        row.add(to: menu)
+        return row
+    }
+
     private var usesUserInstalledAgentCLI: Bool {
         UserDefaults.standard.bool(forKey: RuntimeSettings.useUserInstalledAgentCLIKey)
     }

{agent_cli-0.96.2 → agent_cli-0.96.4}/macos/AgentCLI/Sources/AgentCLI/VoiceLevelOverlay.swift

@@ -94,9 +94,10 @@ final class VoiceLevelMeter: NSObject, ObservableObject {
     private static let barCount = 16
     private static let idleAmplitudes = Array(repeating: CGFloat(0.16), count: barCount)
     private static let minimumDisplayAmplitude = CGFloat(0.12)
+    private static let minimumInputDecibels: Float = -55
     private var engine: AVAudioEngine?
-    private var analyzer: VoiceSpectrumAnalyzer?
-    private var smoothedAmplitudes = VoiceLevelMeter.idleAmplitudes
+    private var phase = 0.0
+    private var smoothedLevel = CGFloat(0.16)
 
     private override init() {}
 
@@ -125,13 +126,14 @@ final class VoiceLevelMeter: NSObject, ObservableObject {
         engine?.inputNode.removeTap(onBus: 0)
         engine?.stop()
         engine = nil
-        analyzer = nil
-        smoothedAmplitudes = Self.idleAmplitudes
+        phase = 0
+        smoothedLevel = 0.16
         amplitudes = Self.idleAmplitudes
     }
 
     private func startMetering() {
-        smoothedAmplitudes = Self.idleAmplitudes
+        phase = 0
+        smoothedLevel = 0.16
         let engine = AVAudioEngine()
         let input = engine.inputNode
         let format = input.outputFormat(forBus: 0)
@@ -139,17 +141,12 @@ final class VoiceLevelMeter: NSObject, ObservableObject {
             amplitudes = Self.idleAmplitudes
             return
         }
-        let analyzer = VoiceSpectrumAnalyzer(
-            sampleRate: format.sampleRate,
-            bandCount: Self.barCount
-        )
 
         do {
             input.installTap(onBus: 0, bufferSize: 1_024, format: format) { [weak self] buffer, _ in
                 self?.process(buffer: buffer)
             }
             try engine.start()
-            self.analyzer = analyzer
             self.engine = engine
         } catch {
             input.removeTap(onBus: 0)
@@ -158,21 +155,47 @@ final class VoiceLevelMeter: NSObject, ObservableObject {
     }
 
     private func process(buffer: AVAudioPCMBuffer) {
-        guard let analyzer, let samples = Self.samples(from: buffer) else { return }
-        let rawAmplitudes = analyzer.amplitudes(from: samples)
+        guard let samples = Self.samples(from: buffer) else { return }
+        let level = Self.normalizedLevel(from: samples)
 
         DispatchQueue.main.async { [weak self] in
             guard let self, self.engine != nil else { return }
-            self.amplitudes = self.smoothedDisplayAmplitudes(from: rawAmplitudes)
+            self.updateDisplay(level: level)
         }
     }
 
-    private func smoothedDisplayAmplitudes(from rawAmplitudes: [CGFloat]) -> [CGFloat] {
-        smoothedAmplitudes = zip(smoothedAmplitudes, rawAmplitudes).map { previous, current in
-            let smoothed = (previous * 0.62) + (current * 0.38)
-            return max(Self.minimumDisplayAmplitude, min(1, smoothed))
+    private func updateDisplay(level: CGFloat) {
+        phase += 0.22
+        smoothedLevel = (smoothedLevel * 0.55) + (level * 0.45)
+        let displayLevel = smoothedLevel
+
+        amplitudes = Self.displayAmplitudes(level: displayLevel, phase: phase)
+    }
+
+    static func displayAmplitudes(level: CGFloat, phase: Double) -> [CGFloat] {
+        (0..<Self.barCount).map { index in
+            let wave = 0.74 + 0.26 * sin(phase + Double(index) * 0.74)
+            return max(Self.minimumDisplayAmplitude, min(1, level * CGFloat(wave)))
         }
-        return smoothedAmplitudes
+    }
+
+    static func normalizedLevel(from samples: [Float]) -> CGFloat {
+        guard !samples.isEmpty else { return 0.08 }
+
+        let meanSquare = samples.reduce(0.0) { partialResult, sample in
+            let value = Double(sample)
+            return partialResult + (value * value)
+        } / Double(samples.count)
+        guard meanSquare > 0 else { return 0.08 }
+
+        let rootMeanSquare = sqrt(meanSquare)
+        let decibels = Float(20 * log10(rootMeanSquare))
+        return normalizedPower(decibels, minimumPower: minimumInputDecibels)
+    }
+
+    private static func normalizedPower(_ power: Float, minimumPower: Float) -> CGFloat {
+        guard power > minimumPower else { return 0.08 }
+        return CGFloat((power - minimumPower) / abs(minimumPower))
     }
 
     private static func samples(from buffer: AVAudioPCMBuffer) -> [Float]? {