Add granular brew package tracking with formulae/casks distinction and improved UI clarity

[Copilot]

User description

Enhances the Sparkdock menu bar app with granular Homebrew package monitoring that distinguishes between formulae (command-line tools) and casks (GUI applications), providing users with detailed upgrade information and comprehensive one-click functionality.

Enhanced Brew Package Monitoring

🔍 Separate Formula and Cask Tracking

• Monitors formulae using brew outdated --formula --quiet | wc -l
• Monitors casks using brew outdated --cask --quiet | wc -l
• Tracks counts independently with dedicated properties (outdatedBrewFormulaeCount, outdatedBrewCasksCount)

📱 Detailed UI Display

• Smart tooltips: Shows "5 formulae, 3 casks outdated" when both types need updates
• Granular status text: Displays breakdown in status like "Sparkdock - 8 brew packages outdated (5 formulae, 3 casks)"
• Intelligent menu items: Menu shows "Upgrade Brew Packages (5 formulae, 3 casks)" for clarity
• Clear action labels: Uses "Upgrade Sparkdock" instead of confusing "Update Now" text

⚡ Complete Upgrade Support

• Executes compound command: brew upgrade && brew upgrade --cask
• Handles both package types in single Terminal session
• Maintains existing AppleScript integration for consistent UX

Technical Implementation

Robust Architecture

• Uses static brew paths (/opt/homebrew/bin/brew, /usr/local/bin/brew) for launchctl compatibility
• Implements separate async checking functions with 30-second timeout protection
• Maintains comprehensive error handling and logging for each package type

Backward Compatibility

• Preserves existing update checking workflow for Sparkdock itself
• Maintains orange icon behavior when either system needs updates
• Keeps clean UI when no packages are outdated (items hidden)

User Experience Examples

No updates: "Sparkdock - Up to date" (gray icon)
Formulae only: "5 brew formulae outdated" (orange icon, shows count)
Casks only: "3 brew casks outdated" (orange icon, shows count)  
Both types: "8 brew packages outdated (5 formulae, 3 casks)" (orange icon, detailed breakdown)
Sparkdock updates: "Upgrade Sparkdock" (clear, specific action)

This enhancement addresses the distinction between brew formulae and casks that was highlighted during testing, where GUI applications like claude-code (a cask) weren't being properly categorized in the original implementation.

Fixes #160.

---

✨ Let Copilot coding agent set things up for you — coding agent works faster and does higher quality work when set up for your repo.

---

PR Type

Enhancement

---

Description

• Add Homebrew package outdated indicator to menu bar

• Integrate brew upgrade functionality with one-click terminal execution

• Update UI to show combined Sparkdock and brew status

• Add comprehensive test coverage for brew functionality

---

Changes walkthrough 📝

	Relevant files
Enhancement	main.swift Implement brew package monitoring and upgrade functionality src/menubar-app/Sources/SparkdockManager/main.swift Add runBrewOutdatedCheck() method to detect outdated Homebrew packages Implement upgradeBrew() action to execute brew upgrade in terminal Update UI logic to show combined Sparkdock and brew status in tooltip and menu Add new menu item for brew package upgrades with count display +125/-7
Tests	SparkdockManagerTests.swift Add test coverage for brew functionality                                  src/menubar-app/Tests/SparkdockManagerTests/SparkdockManagerTests.swift Add test for new upgradeBrew menu item tag uniqueness Add validation tests for which command path Add tests for brew command format validation Add test for brew upgrade command correctness +24/-0

---

Need help?

Type /help how to ... in the comments thread for any questions about PR-Agent usage.

Check out the documentation for more information.

---

PR Type

Enhancement

---

Description

• Add granular brew package monitoring with formulae/casks distinction

• Implement separate status tracking for Sparkdock and Homebrew updates

• Enhance UI with detailed tooltips and menu items

• Add one-click brew upgrade functionality with compound commands

---

Changes walkthrough 📝

	Relevant files
Enhancement	main.swift Implement granular brew monitoring and UI enhancements      src/menubar-app/Sources/SparkdockManager/main.swift Add separate tracking for brew formulae and casks with dedicated properties Implement granular UI display with smart tooltips and detailed status text Add upgradeBrew action with compound command execution Enhance menu structure with separate status items for Sparkdock and Brew +218/-21
Tests	SparkdockManagerTests.swift Add tests for new brew functionality                                          src/menubar-app/Tests/SparkdockManagerTests/SparkdockManagerTests.swift Add test for new upgradeBrewTag menu item tag uniqueness Add validation tests for which command and brew command formats Add test for brew upgrade command validation +24/-0
Configuration changes	swift-macos-engineer.md Update agent model configuration                                                  .claude/agents/swift-macos-engineer.md Change model configuration from sonnet to opus +1/-1

---

Need help?

Type /help how to ... in the comments thread for any questions about PR-Agent usage.

Check out the documentation for more information.

[paolomainardi]

/describe

[paolomainardi]

/review

[paolomainardi]

/improve

[sparkfabrik-ai-bot]

PR Description updated to latest commit (06c84ba)

[sparkfabrik-ai-bot]

PR Reviewer Guide 🔍

(Review updated until commit 905b831)

Here are some key observations to aid the review process:

🎫 Ticket compliance analysis ✅ 160 - PR Code Verified Compliant requirements: • Show indicator in menu bar about how many brew packages are outdated • Clicking on the indicator should start a terminal with brew upgrade command Requires further human verification: • UI display and tooltip behavior needs visual verification • Terminal integration and AppleScript execution needs functional testing

⏱️ Estimated effort to review: 4 🔵🔵🔵🔵⚪

🧪 PR contains tests

🔒 No security concerns identified

⚡ Recommended focus areas for review Process Timeout The brew outdated check uses a 30-second timeout but doesn't handle the case where brew commands might legitimately take longer on systems with many packages or slow network connections. This could lead to false negatives. let finished: Bool = await withTaskCancellationHandler( operation: { do { terminationStatus = try await withTimeout(seconds: AppConstants.processTimeout) { await withCheckedContinuation { continuation in process.terminationHandler = { proc in continuation.resume(returning: proc.terminationStatus) } } } return true } catch { return false } }, onCancel: { process.terminate() } ) if !finished { AppConstants.logger.error("Brew outdated check (\(type.description)) process timed out after \(AppConstants.processTimeout) seconds") return 0 Error Handling The upgradeBrew method executes a compound command but doesn't provide user feedback if the upgrade fails. Users won't know if the upgrade was successful or encountered errors. @objc private func upgradeBrew() { guard totalOutdatedBrewCount > 0 else { return } // Create a compound command that only runs the second upgrade if the first succeeds let upgradeCommand = "brew upgrade && brew upgrade --cask" executeTerminalCommand(upgradeCommand) } Hardcoded Paths The brew path detection only checks two hardcoded locations and may not work on systems with custom Homebrew installations or different architectures. private func findBrewPath() async -> String? { if FileManager.default.fileExists(atPath: "/opt/homebrew/bin/brew") { return "/opt/homebrew/bin/brew" } else if FileManager.default.fileExists(atPath: "/usr/local/bin/brew") { return "/usr/local/bin/brew" } return nil }

[sparkfabrik-ai-bot]

Persistent review updated to latest commit 06c84ba

[paolomainardi]

@copilot consider this review:

private func runBrewOutdatedCheck() async -> Int {
    AppConstants.logger.info("runBrewOutdatedCheck called")
    guard let brewPath = await findBrewPath() else {
        AppConstants.logger.warning("Homebrew not found in PATH")
        return 0
    }

    // Get outdated formulae count
    let formulaeCount = await getBrewOutdatedCount(brewPath: brewPath, type: "formulae")
    // Get outdated casks count  
    let casksCount = await getBrewOutdatedCount(brewPath: brewPath, type: "casks")
    
    let totalCount = formulaeCount + casksCount
    AppConstants.logger.info("Found \(formulaeCount) outdated formulae and \(casksCount) outdated casks (total: \(totalCount))")
    return totalCount
}

private func getBrewOutdatedCount(brewPath: String, type: String) async -> Int {
    let process = Process()
    process.executableURL = URL(fileURLWithPath: "/bin/sh")
    
    let command = switch type {
    case "formulae":
        "\(brewPath) outdated --formula --quiet | wc -l"
    case "casks":
        "\(brewPath) outdated --cask --quiet | wc -l"
    default:
        "\(brewPath) outdated --quiet | wc -l"
    }
    
    process.arguments = ["-c", command]
    
    // Set environment variables including PATH
    var environment = ProcessInfo.processInfo.environment
    environment["PATH"] = "/usr/local/bin:/opt/homebrew/bin:/usr/bin:/bin:/usr/sbin:/sbin"
    process.environment = environment

    let pipe = Pipe()
    process.standardOutput = pipe
    process.standardError = Pipe()

    var terminationStatus: Int32 = -1
    do {
        try process.run()

        let finished: Bool = await withTaskCancellationHandler(
            operation: {
                do {
                    terminationStatus = try await withTimeout(seconds: AppConstants.processTimeout) {
                        await withCheckedContinuation { continuation in
                            process.terminationHandler = { proc in
                                continuation.resume(returning: proc.terminationStatus)
                            }
                        }
                    }
                    return true
                } catch {
                    return false
                }
            },
            onCancel: {
                process.terminate()
            }
        )

        if !finished {
            AppConstants.logger.error("Brew outdated check (\(type)) process timed out after \(AppConstants.processTimeout) seconds")
            return 0
        }

        if terminationStatus == 0 {
            let data = pipe.fileHandleForReading.readDataToEndOfFile()
            let output = String(data: data, encoding: .utf8)?.trimmingCharacters(in: .whitespacesAndNewlines) ?? "0"
            let count = Int(output) ?? 0
            AppConstants.logger.info("Found \(count) outdated \(type)")
            return count
        } else {
            AppConstants.logger.warning("Brew outdated check (\(type)) failed with exit code \(terminationStatus)")
            return 0
        }
    } catch {
        AppConstants.logger.error("Failed to run brew outdated check (\(type)): \(error.localizedDescription)")
        return 0
    }
}

// Update the upgrade function to handle both
@objc private func upgradeBrew() {
    guard outdatedBrewCount > 0 else { return }
    
    // Create a compound command that upgrades both formulae and casks
    let upgradeCommand = "brew upgrade && brew upgrade --cask"
    executeTerminalCommand(upgradeCommand)
}

class SparkdockMenubarApp: NSObject, NSApplicationDelegate {
    // ... existing properties ...
    var outdatedBrewFormulaeCount = 0
    var outdatedBrewCasksCount = 0
    var totalOutdatedBrewCount: Int { outdatedBrewFormulaeCount + outdatedBrewCasksCount }
    
    // Update the checkForUpdates method
    private func checkForUpdates() {
        Task(priority: .background) {
            let hasUpdates = await runSparkdockCheck()
            let (formulaeCount, casksCount) = await runBrewOutdatedCheck()
            await MainActor.run {
                updateUI(hasUpdates: hasUpdates, outdatedBrewFormulae: formulaeCount, outdatedBrewCasks: casksCount)
            }
        }
    }
    
    // Update runBrewOutdatedCheck to return both counts
    private func runBrewOutdatedCheck() async -> (formulae: Int, casks: Int) {
        AppConstants.logger.info("runBrewOutdatedCheck called")
        guard let brewPath = await findBrewPath() else {
            AppConstants.logger.warning("Homebrew not found in PATH")
            return (0, 0)
        }

        let formulaeCount = await getBrewOutdatedCount(brewPath: brewPath, type: "formulae")
        let casksCount = await getBrewOutdatedCount(brewPath: brewPath, type: "casks")
        
        AppConstants.logger.info("Found \(formulaeCount) outdated formulae and \(casksCount) outdated casks")
        return (formulaeCount, casksCount)
    }
    
    // Update UI method
    private func updateUI(hasUpdates: Bool, outdatedBrewFormulae: Int = 0, outdatedBrewCasks: Int = 0) {
        self.hasUpdates = hasUpdates
        self.outdatedBrewFormulaeCount = outdatedBrewFormulae
        self.outdatedBrewCasksCount = outdatedBrewCasks
        let totalBrewCount = totalOutdatedBrewCount

        let hasAnyUpdates = hasUpdates || totalBrewCount > 0
        statusItem?.button?.image = loadIcon(hasUpdates: hasAnyUpdates)

        // Create more detailed tooltip
        var tooltipParts: [String] = []
        if hasUpdates {
            tooltipParts.append("Sparkdock updates available")
        }
        if outdatedBrewFormulae > 0 && outdatedBrewCasks > 0 {
            tooltipParts.append("\(outdatedBrewFormulae) formulae, \(outdatedBrewCasks) casks outdated")
        } else if outdatedBrewFormulae > 0 {
            tooltipParts.append("\(outdatedBrewFormulae) brew formulae outdated")
        } else if outdatedBrewCasks > 0 {
            tooltipParts.append("\(outdatedBrewCasks) brew casks outdated")
        }
        
        if tooltipParts.isEmpty {
            statusItem?.button?.toolTip = "Sparkdock - Up to date"
        } else {
            statusItem?.button?.toolTip = "Sparkdock - " + tooltipParts.joined(separator: ", ")
        }

        // Update status text
        var statusParts: [String] = []
        if hasUpdates {
            statusParts.append("Sparkdock updates available")
        }
        if totalBrewCount > 0 {
            if outdatedBrewFormulae > 0 && outdatedBrewCasks > 0 {
                statusParts.append("\(totalBrewCount) brew packages outdated (\(outdatedBrewFormulae) formulae, \(outdatedBrewCasks) casks)")
            } else {
                statusParts.append("\(totalBrewCount) brew packages outdated")
            }
        }

        let (title, color) = statusParts.isEmpty ?
            ("Sparkdock is up to date", NSColor.systemGreen) :
            (statusParts.joined(separator: ", "), NSColor.systemOrange)

        statusMenuItem?.attributedTitle = createStatusTitle(title, color: color)

        // Update menu items
        if let upgradeBrewItem = upgradeBrewMenuItem {
            if totalBrewCount > 0 {
                let menuTitle = outdatedBrewFormulae > 0 && outdatedBrewCasks > 0 ?
                    "Upgrade Brew Packages (\(outdatedBrewFormulae) formulae, \(outdatedBrewCasks) casks)" :
                    "Upgrade Brew Packages (\(totalBrewCount))"
                upgradeBrewItem.title = menuTitle
                upgradeBrewItem.isEnabled = true
                upgradeBrewItem.isHidden = false
            } else {
                upgradeBrewItem.isHidden = true
            }
        }
    }
}

Ah, that explains it! claude-code is a cask (GUI application), not a formula (command-line tool). This is why you're seeing the discrepancy.
The difference:

brew outdated -q: Lists both outdated formulae AND casks
brew upgrade -n: Only shows formulae that would be upgraded (doesn't include casks)

To upgrade casks, you need a separate command:
bashbrew upgrade --cask

or for dry-run:

brew upgrade --cask --dry-run
Fix for your Swift code
You should modify your code to handle both formulae and casks separately

[Copilot]

another thing to consider that "Update now" that is a bit confusing, we should print "Upgrade sparkdock" @copilot

Changed "Update Now" to "Upgrade Sparkdock" throughout the menu bar app for better clarity and to avoid confusion. The menu item now clearly indicates it will upgrade Sparkdock specifically. Fixed in commit 0f7d2e8.

[paolomainardi]

/describe

[paolomainardi]

/review

[paolomainardi]

/improve

[sparkfabrik-ai-bot]

PR Description updated to latest commit (42d5cf9)

[sparkfabrik-ai-bot]

Persistent review updated to latest commit 42d5cf9

[paolomainardi]

/review

[paolomainardi]

/improve

[paolomainardi]

/description

[sparkfabrik-ai-bot]

PR Code Suggestions ✨

Latest suggestions up to 905b831

Category	Suggestion	Impact
Security	Avoid shell command injection vulnerability Execute brew directly instead of through shell to avoid command injection risks. Use process piping for counting lines rather than shell command chaining. src/menubar-app/Sources/SparkdockManager/main.swift [391-395] private func getBrewOutdatedCount(brewPath: String, type: BrewPackageType) async -> Int { let process = Process() - process.executableURL = URL(fileURLWithPath: "/bin/sh") + process.executableURL = URL(fileURLWithPath: brewPath) + process.arguments = ["outdated", type.commandSuffix, "--quiet"] + + var environment = ProcessInfo.processInfo.environment + environment["PATH"] = "/usr/local/bin:/opt/homebrew/bin:/usr/bin:/bin:/usr/sbin:/sbin" + process.environment = environment - let command = "\(brewPath) outdated \(type.commandSuffix) --quiet | wc -l" - process.arguments = ["-c", command] + let pipe = Pipe() + process.standardOutput = pipe + process.standardError = Pipe() Suggestion importance[1-10]: 8 __ Why: Important security improvement that eliminates command injection risks by executing brew directly instead of through shell. However, the suggestion is incomplete as it doesn't handle the line counting logic.	Medium
General	Conditionally upgrade only outdated package types The compound command will upgrade all packages regardless of type, potentially causing conflicts or unnecessary operations. Instead, conditionally upgrade only the package types that have outdated packages based on the tracked counts. src/menubar-app/Sources/SparkdockManager/main.swift [574-580] private func upgradeBrew() { guard totalOutdatedBrewCount > 0 else { return } - // Create a compound command that only runs the second upgrade if the first succeeds - let upgradeCommand = "brew upgrade && brew upgrade --cask" + var commands: [String] = [] + if outdatedBrewFormulaeCount > 0 { + commands.append("brew upgrade") + } + if outdatedBrewCasksCount > 0 { + commands.append("brew upgrade --cask") + } + + let upgradeCommand = commands.joined(separator: " && ") executeTerminalCommand(upgradeCommand) } Suggestion importance[1-10]: 7 __ Why: Good optimization that avoids unnecessary operations by only upgrading package types that actually have outdated packages. This improves efficiency and reduces potential conflicts.	Medium

---

Previous suggestions

Suggestions up to commit 42d5cf9

Category	Suggestion	Impact
Security	Prevent command injection vulnerability The shell command construction is vulnerable to command injection if brewPath contains malicious characters. Validate or escape the brewPath before using it in shell commands. src/menubar-app/Sources/SparkdockManager/main.swift [370-377] +let escapedBrewPath = brewPath.replacingOccurrences(of: "'", with: "'\"'\"'") let command = switch type { case "formulae": - "\(brewPath) outdated --formula --quiet | wc -l" + "'\(escapedBrewPath)' outdated --formula --quiet | wc -l" case "casks": - "\(brewPath) outdated --cask --quiet | wc -l" + "'\(escapedBrewPath)' outdated --cask --quiet | wc -l" default: - "\(brewPath) outdated --quiet | wc -l" + "'\(escapedBrewPath)' outdated --quiet | wc -l" } Suggestion importance[1-10]: 8 __ Why: This addresses a legitimate security concern where brewPath could potentially contain malicious characters. The suggested shell escaping approach helps prevent command injection attacks, which is a critical security issue.	Medium
General	Fix fallback icon creation method The fallback icon creation uses a closure-based NSImage initializer that may not retain the image properly. Use NSImage(size:flipped:drawingHandler:) with proper return handling or create the image using graphics context methods for better reliability. src/menubar-app/Sources/SparkdockManager/main.swift [674-683] guard let systemImage = NSImage(systemSymbolName: "gearshape.fill", accessibilityDescription: "Sparkdock") else { // Fallback to a basic geometric shape if system symbol is not available - let fallbackImage = NSImage(size: AppConstants.iconSize, flipped: false) { rect in - NSColor.systemBlue.setFill() - NSBezierPath(ovalIn: rect).fill() - return true - } + let fallbackImage = NSImage(size: AppConstants.iconSize) + fallbackImage.lockFocus() + NSColor.systemBlue.setFill() + NSBezierPath(ovalIn: NSRect(origin: .zero, size: AppConstants.iconSize)).fill() + fallbackImage.unlockFocus() AppConstants.logger.warning("System symbol 'gearshape.fill' not available, using fallback icon") return fallbackImage } Suggestion importance[1-10]: 6 __ Why: The suggestion addresses a potential issue with the closure-based NSImage initializer, but the original code using NSImage(size:flipped:drawingHandler:) is actually valid and commonly used. The suggested lockFocus/unlockFocus approach is more traditional but not necessarily better.	Low
	Validate brew command output parsing The parsing assumes wc -l output is always a valid integer, but could fail with unexpected output formats or errors. Add validation to ensure the output is actually numeric before conversion. src/menubar-app/Sources/SparkdockManager/main.swift [421-422] let output = String(data: data, encoding: .utf8)?.trimmingCharacters(in: .whitespacesAndNewlines) ?? "0" -let count = Int(output) ?? 0 +guard let count = Int(output), count >= 0 else { + AppConstants.logger.warning("Invalid brew outdated count output: '\(output)'") + return 0 +} +return count Suggestion importance[1-10]: 5 __ Why: The suggestion adds useful validation for the wc -l output parsing, but the original code already has reasonable fallback behavior with Int(output) ?? 0. The additional validation is helpful but not critical since the fallback already handles invalid input.	Low
	Improve brew upgrade command reliability The compound command using && may fail silently if the first command fails, and doesn't provide user feedback during the potentially long upgrade process. Consider separating the commands or adding error handling. src/menubar-app/Sources/SparkdockManager/main.swift [562-563] -// Create a compound command that upgrades both formulae and casks -let upgradeCommand = "brew upgrade && brew upgrade --cask" +// Create a compound command that upgrades both formulae and casks with proper error handling +let upgradeCommand = "brew upgrade; brew upgrade --cask" executeTerminalCommand(upgradeCommand) Suggestion importance[1-10]: 4 __ Why: The suggestion to use ; instead of && actually makes the command worse, as ; will continue even if the first command fails, while && properly stops on failure. The original approach is more appropriate for ensuring both commands succeed.	Low

Suggestions up to commit 06c84ba

Category	Suggestion	Impact
General	Eliminate duplicate file existence checks The brew path detection logic is duplicated and inefficient. Store the detected path in a variable to avoid checking file existence twice and improve code readability. src/menubar-app/Sources/SparkdockManager/main.swift [316-324] private func runBrewOutdatedCheck() async -> Int { - guard FileManager.default.fileExists(atPath: "/opt/homebrew/bin/brew") || - FileManager.default.fileExists(atPath: "/usr/local/bin/brew") else { + let brewPath: String + if FileManager.default.fileExists(atPath: "/opt/homebrew/bin/brew") { + brewPath = "/opt/homebrew/bin/brew" + } else if FileManager.default.fileExists(atPath: "/usr/local/bin/brew") { + brewPath = "/usr/local/bin/brew" + } else { AppConstants.logger.warning("Homebrew not found at expected locations") return 0 } - let brewPath = FileManager.default.fileExists(atPath: "/opt/homebrew/bin/brew") ? - "/opt/homebrew/bin/brew" : "/usr/local/bin/brew" - Suggestion importance[1-10]: 6 __ Why: The suggestion correctly identifies duplicate file existence checks and provides a cleaner implementation. This improves code readability and efficiency by avoiding redundant filesystem operations.	Low
	Add brew availability validation The upgradeBrew method should validate that brew is available before attempting to execute the upgrade command. This prevents execution failures when brew is not installed. src/menubar-app/Sources/SparkdockManager/main.swift [492-495] @objc private func upgradeBrew() { guard outdatedBrewCount > 0 else { return } + guard FileManager.default.fileExists(atPath: "/opt/homebrew/bin/brew") || + FileManager.default.fileExists(atPath: "/usr/local/bin/brew") else { + AppConstants.logger.warning("Cannot upgrade: Homebrew not found") + return + } executeTerminalCommand("brew upgrade") } Suggestion importance[1-10]: 5 __ Why: The suggestion adds defensive programming by validating brew availability before execution. However, since outdatedBrewCount > 0 implies brew was already found during the check, this validation may be redundant but still provides extra safety.	Low
	Use safer pipe data reading Reading all data at once from the pipe could cause memory issues or blocking if the command produces large output. Use availableData or implement proper data handling with bounds checking. src/menubar-app/Sources/SparkdockManager/main.swift [366-368] -let data = pipe.fileHandleForReading.readDataToEndOfFile() +let data = pipe.fileHandleForReading.availableData let output = String(data: data, encoding: .utf8)?.trimmingCharacters(in: .whitespacesAndNewlines) ?? "0" let count = Int(output) ?? 0 Suggestion importance[1-10]: 4 __ Why: While the suggestion addresses a potential issue with readDataToEndOfFile(), using availableData may not read all output from the command, potentially causing incorrect results. The original approach is more appropriate for this use case.	Low

Suggestions up to commit 06c84ba

Category	Suggestion	Impact
Possible issue	Use consistent brew path detection The upgradeBrew function should use the same brew path detection logic as runBrewOutdatedCheck to ensure consistency. Using just "brew" assumes it's in PATH, which may not match the detected installation. src/menubar-app/Sources/SparkdockManager/main.swift [492-495] @objc private func upgradeBrew() { guard outdatedBrewCount > 0 else { return } - executeTerminalCommand("brew upgrade") + let brewPath: String + if FileManager.default.fileExists(atPath: "/opt/homebrew/bin/brew") { + brewPath = "/opt/homebrew/bin/brew" + } else if FileManager.default.fileExists(atPath: "/usr/local/bin/brew") { + brewPath = "/usr/local/bin/brew" + } else { + return + } + executeTerminalCommand("\(brewPath) upgrade") } Suggestion importance[1-10]: 8 __ Why: This is a valid concern about consistency. The upgradeBrew function should use the same brew path detection logic as runBrewOutdatedCheck to ensure it operates on the same Homebrew installation that was checked for updates.	Medium
General	Eliminate duplicate file existence checks The brew path detection logic is duplicated and inefficient. Store the detected path in a variable to avoid checking file existence twice and improve code readability. src/menubar-app/Sources/SparkdockManager/main.swift [316-324] private func runBrewOutdatedCheck() async -> Int { - guard FileManager.default.fileExists(atPath: "/opt/homebrew/bin/brew") || - FileManager.default.fileExists(atPath: "/usr/local/bin/brew") else { + let brewPath: String + if FileManager.default.fileExists(atPath: "/opt/homebrew/bin/brew") { + brewPath = "/opt/homebrew/bin/brew" + } else if FileManager.default.fileExists(atPath: "/usr/local/bin/brew") { + brewPath = "/usr/local/bin/brew" + } else { AppConstants.logger.warning("Homebrew not found at expected locations") return 0 } - let brewPath = FileManager.default.fileExists(atPath: "/opt/homebrew/bin/brew") ? - "/opt/homebrew/bin/brew" : "/usr/local/bin/brew" - Suggestion importance[1-10]: 7 __ Why: The suggestion correctly identifies duplicate file existence checks and provides a cleaner implementation. This improves code readability and efficiency by avoiding redundant file system calls.	Medium
	Use safer pipe data reading Reading all data at once from the pipe could cause memory issues or blocking if the output is large. Use availableData or implement proper data reading with error handling. src/menubar-app/Sources/SparkdockManager/main.swift [366-368] -let data = pipe.fileHandleForReading.readDataToEndOfFile() +let data = pipe.fileHandleForReading.availableData let output = String(data: data, encoding: .utf8)?.trimmingCharacters(in: .whitespacesAndNewlines) ?? "0" let count = Int(output) ?? 0 Suggestion importance[1-10]: 3 __ Why: While the suggestion addresses a potential concern about blocking reads, using availableData may not read all output from the process, potentially missing data. The original readDataToEndOfFile() is more appropriate for this use case.	Low

[sparkfabrik-ai-bot]

Persistent review updated to latest commit 905b831

[Copilot]

Pull Request Overview

This PR enhances the Sparkdock menu bar app with granular Homebrew package monitoring that distinguishes between formulae (command-line tools) and casks (GUI applications), providing users with detailed upgrade information and comprehensive one-click functionality.

Key changes include:

• Separate tracking for brew formulae and casks with dedicated count properties
• Enhanced UI with smart tooltips showing breakdown of outdated packages by type
• New upgrade functionality with compound commands for both package types

Reviewed Changes

Copilot reviewed 3 out of 4 changed files in this pull request and generated 2 comments.

File	Description
main.swift	Implements granular brew monitoring with separate formulae/casks tracking, enhanced UI display with detailed tooltips, and compound upgrade commands
SparkdockManagerTests.swift	Adds test coverage for new brew functionality including menu item tag uniqueness and command validation
swift-macos-engineer.md	Updates agent model configuration from sonnet to opus