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

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

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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agent-cli
-Version: 0.96.1
+Version: 0.96.2
 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/macos/AgentCLI/Sources/AgentCLI/VoiceSpectrumAnalyzer.swift

@@ -0,0 +1,144 @@
+import CoreGraphics
+import Foundation
+
+final class VoiceSpectrumAnalyzer {
+    private static let minimumDisplayDecibels = -60.0
+    private static let maximumDisplayDecibels = -18.0
+
+    private let sampleRate: Double
+    private let bandCount: Int
+    private let centerFrequencies: [Double]
+    private let frequencyBands: [(lower: Double, upper: Double)]
+
+    init(sampleRate: Double, bandCount: Int) {
+        self.sampleRate = sampleRate
+        self.bandCount = bandCount
+
+        let lowFrequency = 80.0
+        let highFrequency = min(7_600.0, max(lowFrequency, sampleRate * 0.46))
+        let denominator = max(1, bandCount - 1)
+        self.centerFrequencies = (0..<bandCount).map { index in
+            let fraction = Double(index) / Double(denominator)
+            return lowFrequency * pow(highFrequency / lowFrequency, fraction)
+        }
+        self.frequencyBands = Self.frequencyBands(
+            centerFrequencies: centerFrequencies,
+            lowFrequency: lowFrequency,
+            highFrequency: highFrequency
+        )
+    }
+
+    func amplitudes(from samples: [Float]) -> [CGFloat] {
+        guard !samples.isEmpty else {
+            return Array(repeating: 0, count: bandCount)
+        }
+
+        let sampleCount = samples.count
+        let windowedSamples = samples.enumerated().map { index, sample in
+            Float(Self.hannWindowValue(index: index, sampleCount: sampleCount)) * sample
+        }
+        let normalization = max(1, Self.hannWindowSum(sampleCount: sampleCount) / 2)
+
+        let frequencyResolution = sampleRate / Double(sampleCount)
+        let maximumBin = max(1, sampleCount / 2)
+
+        return frequencyBands.enumerated().map { index, band in
+            let magnitude = Self.bandMagnitude(
+                band: band,
+                centerFrequency: centerFrequencies[index],
+                frequencyResolution: frequencyResolution,
+                maximumBin: maximumBin,
+                sampleRate: sampleRate,
+                samples: windowedSamples
+            ) / normalization
+            return CGFloat(Self.normalizedDisplayAmplitude(forMagnitude: magnitude))
+        }
+    }
+
+    private static func frequencyBands(
+        centerFrequencies: [Double],
+        lowFrequency: Double,
+        highFrequency: Double
+    ) -> [(lower: Double, upper: Double)] {
+        centerFrequencies.enumerated().map { index, centerFrequency in
+            let lower = index == 0
+                ? lowFrequency
+                : sqrt(centerFrequencies[index - 1] * centerFrequency)
+            let upper = index == centerFrequencies.count - 1
+                ? highFrequency
+                : sqrt(centerFrequency * centerFrequencies[index + 1])
+            return (lower, upper)
+        }
+    }
+
+    private static func bandMagnitude(
+        band: (lower: Double, upper: Double),
+        centerFrequency: Double,
+        frequencyResolution: Double,
+        maximumBin: Int,
+        sampleRate: Double,
+        samples: [Float]
+    ) -> Double {
+        let lowerBin = max(1, Int(ceil(band.lower / frequencyResolution)))
+        let upperBin = min(maximumBin, Int(floor(band.upper / frequencyResolution)))
+
+        if lowerBin <= upperBin {
+            var maximumMagnitude = 0.0
+            for bin in lowerBin...upperBin {
+                maximumMagnitude = max(
+                    maximumMagnitude,
+                    magnitude(
+                        frequency: Double(bin) * frequencyResolution,
+                        sampleRate: sampleRate,
+                        samples: samples
+                    )
+                )
+            }
+            return maximumMagnitude
+        }
+
+        let nearestCenterBin = min(maximumBin, max(1, Int((centerFrequency / frequencyResolution).rounded())))
+        return magnitude(
+            frequency: Double(nearestCenterBin) * frequencyResolution,
+            sampleRate: sampleRate,
+            samples: samples
+        )
+    }
+
+    private static func normalizedDisplayAmplitude(forMagnitude magnitude: Double) -> Double {
+        guard magnitude > 0 else { return 0 }
+
+        let decibels = 20 * log10(max(magnitude, Double.leastNonzeroMagnitude))
+        let normalized = (decibels - minimumDisplayDecibels) / (maximumDisplayDecibels - minimumDisplayDecibels)
+        return min(1, max(0, normalized))
+    }
+
+    private static func magnitude(
+        frequency: Double,
+        sampleRate: Double,
+        samples: [Float]
+    ) -> Double {
+        let radiansPerSample = 2 * Double.pi * frequency / sampleRate
+        var real = 0.0
+        var imaginary = 0.0
+
+        for (index, sample) in samples.enumerated() {
+            let angle = radiansPerSample * Double(index)
+            let value = Double(sample)
+            real += value * cos(angle)
+            imaginary -= value * sin(angle)
+        }
+
+        return sqrt((real * real) + (imaginary * imaginary))
+    }
+
+    private static func hannWindowValue(index: Int, sampleCount: Int) -> Double {
+        guard sampleCount > 1 else { return 1 }
+        return 0.5 - (0.5 * cos(2 * Double.pi * Double(index) / Double(sampleCount - 1)))
+    }
+
+    private static func hannWindowSum(sampleCount: Int) -> Double {
+        guard sampleCount > 1 else { return 1 }
+        return Double(sampleCount - 1) / 2
+    }
+}

{agent_cli-0.96.1 → agent_cli-0.96.2}/macos/AgentCLI/Tests/AgentCLITests/VoiceSpectrumAnalyzerTests.swift

@@ -29,13 +29,25 @@ final class VoiceSpectrumAnalyzerTests: XCTestCase {
         XCTAssertTrue(amplitudes.allSatisfy { $0 == 0 })
     }
 
+    func testQuietSpeechLevelToneRisesAboveOverlayFloor() {
+        let analyzer = VoiceSpectrumAnalyzer(sampleRate: 16_000, bandCount: 16)
+        let quietSpeechLevel = pow(10.0, -45.0 / 20.0)
+
+        let amplitudes = analyzer.amplitudes(
+            from: Self.sineWave(frequency: 220, sampleRate: 16_000, amplitude: Float(quietSpeechLevel))
+        )
+
+        XCTAssertGreaterThan(amplitudes.max() ?? 0, 0.2)
+    }
+
     private static func sineWave(
         frequency: Double,
         sampleRate: Double,
-        sampleCount: Int = 2_048
+        sampleCount: Int = 2_048,
+        amplitude: Float = 1
     ) -> [Float] {
         (0..<sampleCount).map { index in
-            Float(sin(2 * Double.pi * frequency * Double(index) / sampleRate))
+            amplitude * Float(sin(2 * Double.pi * frequency * Double(index) / sampleRate))
         }
     }
 }

{agent_cli-0.96.1 → agent_cli-0.96.2}/macos/appcast.xml

@@ -4,6 +4,24 @@
         <title>Agent CLI Updates</title>
         <link>https://github.com/basnijholt/agent-cli</link>
         <description>Signed Agent CLI macOS app updates.</description>
+        <item>
+            <title>0.96.1</title>
+            <pubDate>Fri, 29 May 2026 05:47:47 +0000</pubDate>
+            <link>https://github.com/basnijholt/agent-cli</link>
+            <sparkle:version>175</sparkle:version>
+            <sparkle:shortVersionString>0.96.1</sparkle:shortVersionString>
+            <sparkle:minimumSystemVersion>13.0</sparkle:minimumSystemVersion>
+            <sparkle:hardwareRequirements>arm64</sparkle:hardwareRequirements>
+            <description sparkle:format="markdown"><![CDATA[## What’s Changed
+
+* Clean up macOS menu lifecycle wiring (#545) @basnijholt
+* Remove uv Python 3.13 install workarounds (#521) @basnijholt
+* Remove brittle macOS source-shape tests (#547) @basnijholt
+* Fix macOS voice meter source assertions (#546) @basnijholt
+
+]]></description>
+            <enclosure url="https://github.com/basnijholt/agent-cli/releases/download/v0.96.1/AgentCLI.zip" length="22729845" type="application/octet-stream" sparkle:edSignature="YYq/64CSi+pxZD2NZ02GWIPAdusUf3mesEQ4MltVUOSheuOwimOZpHs81brT4g8rFBa2PRfnobfrfcTtfONqCQ=="/>
+        </item>
         <item>
             <title>0.96.0</title>
             <pubDate>Fri, 29 May 2026 05:30:42 +0000</pubDate>

agent_cli-0.96.1/macos/AgentCLI/Sources/AgentCLI/VoiceSpectrumAnalyzer.swift

@@ -1,71 +0,0 @@
-import CoreGraphics
-import Foundation
-
-final class VoiceSpectrumAnalyzer {
-    private let sampleRate: Double
-    private let bandCount: Int
-    private let centerFrequencies: [Double]
-
-    init(sampleRate: Double, bandCount: Int) {
-        self.sampleRate = sampleRate
-        self.bandCount = bandCount
-
-        let lowFrequency = 80.0
-        let highFrequency = min(7_600.0, max(lowFrequency, sampleRate * 0.46))
-        let denominator = max(1, bandCount - 1)
-        self.centerFrequencies = (0..<bandCount).map { index in
-            let fraction = Double(index) / Double(denominator)
-            return lowFrequency * pow(highFrequency / lowFrequency, fraction)
-        }
-    }
-
-    func amplitudes(from samples: [Float]) -> [CGFloat] {
-        guard !samples.isEmpty else {
-            return Array(repeating: 0, count: bandCount)
-        }
-
-        let sampleCount = samples.count
-        let windowedSamples = samples.enumerated().map { index, sample in
-            Float(Self.hannWindowValue(index: index, sampleCount: sampleCount)) * sample
-        }
-        let normalization = max(1, Self.hannWindowSum(sampleCount: sampleCount) / 2)
-
-        return centerFrequencies.map { frequency in
-            let magnitude = Self.magnitude(
-                frequency: frequency,
-                sampleRate: sampleRate,
-                samples: windowedSamples
-            ) / normalization
-            return CGFloat(min(1, sqrt(magnitude) * 1.35))
-        }
-    }
-
-    private static func magnitude(
-        frequency: Double,
-        sampleRate: Double,
-        samples: [Float]
-    ) -> Double {
-        let radiansPerSample = 2 * Double.pi * frequency / sampleRate
-        var real = 0.0
-        var imaginary = 0.0
-
-        for (index, sample) in samples.enumerated() {
-            let angle = radiansPerSample * Double(index)
-            let value = Double(sample)
-            real += value * cos(angle)
-            imaginary -= value * sin(angle)
-        }
-
-        return sqrt((real * real) + (imaginary * imaginary))
-    }
-
-    private static func hannWindowValue(index: Int, sampleCount: Int) -> Double {
-        guard sampleCount > 1 else { return 1 }
-        return 0.5 - (0.5 * cos(2 * Double.pi * Double(index) / Double(sampleCount - 1)))
-    }
-
-    private static func hannWindowSum(sampleCount: Int) -> Double {
-        guard sampleCount > 1 else { return 1 }
-        return Double(sampleCount - 1) / 2
-    }
-}