feat(ui): integrate display brightness slider and historical trend charts into main views

Sources/App/MacMonitorApp.swift

@@ -11,5 +11,15 @@ struct MacMonitorApp: App {
         .windowStyle(.titleBar)
         .windowToolbarStyle(.unified)
         .defaultSize(width: 960, height: 640)
+        
+        MenuBarExtra {
+            QuickGlancePopoverView(store: store)
+        } label: {
+            MenuBarStatusView(
+                cpuLoad: store.cpuLoad.totalLoad,
+                memoryPercent: store.memory.utilizationPercentage
+            )
+        }
+        .menuBarExtraStyle(.window)
     }
 }

Sources/App/SystemTelemetryStore.swift

@@ -252,6 +252,13 @@ public final class SystemTelemetryStore {
     public private(set) var batteryHealth = BatteryHealthMetrics()
     public private(set) var peripherals: [PeripheralDeviceItem] = []
     public private(set) var audioDevices: [AudioDeviceItem] = []
+    public private(set) var displays: [MMDisplayInfo] = []
+    
+    /// Historical Telemetry Store
+    public let historyStore = TelemetryHistoryStore.shared
+    
+    /// Display Manager helper
+    public let displayManager = MMDisplayManager.shared()
     
     /// Process detail inspection helper
     public let processInspector = MMProcessDetailInspector()
@@ -653,6 +660,28 @@ public final class SystemTelemetryStore {
                 )
             }
         }
+        
+        // 18. Display Hardware
+        self.displays = self.displayManager.activeDisplays()
+        
+        // 19. Record to Historical Ring Buffers
+        let totalDownBps = self.networkBandwidth.reduce(0.0) { $0 + $1.downloadBps }
+        let totalUpBps = self.networkBandwidth.reduce(0.0) { $0 + $1.uploadBps }
+        let totalDiskReadBps = self.diskIO.reduce(0.0) { $0 + $1.readBps }
+        let totalDiskWriteBps = self.diskIO.reduce(0.0) { $0 + $1.writeBps }
+        
+        let snapshotRecord = TelemetrySnapshotRecord(
+            cpuLoad: self.cpuLoad.totalLoad,
+            memoryUsedPercent: self.memory.utilizationPercentage,
+            networkInBps: totalDownBps,
+            networkOutBps: totalUpBps,
+            diskReadBps: totalDiskReadBps,
+            diskWriteBps: totalDiskWriteBps,
+            cpuTemp: self.cpuThermal.packageTemperature,
+            systemPowerWatts: self.power.systemTotalWatts,
+            timestamp: self.lastUpdateTimestamp
+        )
+        self.historyStore.record(snapshot: snapshotRecord)
     }
     
     public func terminateProcess(pid: pid_t, force: Bool) -> Bool {

Sources/History/RollingRingBuffer.swift

@@ -0,0 +1,54 @@
+import Foundation
+
+public struct HistoricalSample<T>: Identifiable {
+    public let id: UUID
+    public let timestamp: Date
+    public let value: T
+    
+    public init(timestamp: Date = Date(), value: T) {
+        self.id = UUID()
+        self.timestamp = timestamp
+        self.value = value
+    }
+}
+
+public final class RollingRingBuffer<T> {
+    private var buffer: [HistoricalSample<T>]
+    private let capacity: Int
+    private let lock = NSLock()
+    
+    public init(capacity: Int = 60) {
+        self.capacity = max(1, capacity)
+        self.buffer = []
+        self.buffer.reserveCapacity(self.capacity)
+    }
+    
+    public func append(_ value: T, timestamp: Date = Date()) {
+        lock.lock()
+        defer { lock.unlock() }
+        
+        let sample = HistoricalSample(timestamp: timestamp, value: value)
+        if buffer.count >= capacity {
+            buffer.removeFirst()
+        }
+        buffer.append(sample)
+    }
+    
+    public var samples: [HistoricalSample<T>] {
+        lock.lock()
+        defer { lock.unlock() }
+        return buffer
+    }
+    
+    public var count: Int {
+        lock.lock()
+        defer { lock.unlock() }
+        return buffer.count
+    }
+    
+    public func clear() {
+        lock.lock()
+        defer { lock.unlock() }
+        buffer.removeAll(keepingCapacity: true)
+    }
+}

Sources/History/TelemetryHistoryStore.swift

@@ -0,0 +1,66 @@
+import Foundation
+import SwiftUI
+
+public struct TelemetrySnapshotRecord {
+    public let cpuLoad: Double
+    public let memoryUsedPercent: Double
+    public let networkInBps: Double
+    public let networkOutBps: Double
+    public let diskReadBps: Double
+    public let diskWriteBps: Double
+    public let cpuTemp: Double
+    public let systemPowerWatts: Double
+    public let timestamp: Date
+    
+    public init(
+        cpuLoad: Double = 0.0,
+        memoryUsedPercent: Double = 0.0,
+        networkInBps: Double = 0.0,
+        networkOutBps: Double = 0.0,
+        diskReadBps: Double = 0.0,
+        diskWriteBps: Double = 0.0,
+        cpuTemp: Double = 0.0,
+        systemPowerWatts: Double = 0.0,
+        timestamp: Date = Date()
+    ) {
+        self.cpuLoad = cpuLoad
+        self.memoryUsedPercent = memoryUsedPercent
+        self.networkInBps = networkInBps
+        self.networkOutBps = networkOutBps
+        self.diskReadBps = diskReadBps
+        self.diskWriteBps = diskWriteBps
+        self.cpuTemp = cpuTemp
+        self.systemPowerWatts = systemPowerWatts
+        self.timestamp = timestamp
+    }
+}
+
+@Observable
+public final class TelemetryHistoryStore {
+    public static let shared = TelemetryHistoryStore()
+    
+    public let cpuHistory = RollingRingBuffer<Double>(capacity: 60)
+    public let memoryHistory = RollingRingBuffer<Double>(capacity: 60)
+    public let networkInHistory = RollingRingBuffer<Double>(capacity: 60)
+    public let networkOutHistory = RollingRingBuffer<Double>(capacity: 60)
+    public let diskReadHistory = RollingRingBuffer<Double>(capacity: 60)
+    public let diskWriteHistory = RollingRingBuffer<Double>(capacity: 60)
+    public let cpuTempHistory = RollingRingBuffer<Double>(capacity: 60)
+    public let powerHistory = RollingRingBuffer<Double>(capacity: 60)
+    
+    public private(set) var sampleCounter: UInt64 = 0
+    
+    public init() {}
+    
+    public func record(snapshot: TelemetrySnapshotRecord) {
+        cpuHistory.append(snapshot.cpuLoad, timestamp: snapshot.timestamp)
+        memoryHistory.append(snapshot.memoryUsedPercent, timestamp: snapshot.timestamp)
+        networkInHistory.append(snapshot.networkInBps, timestamp: snapshot.timestamp)
+        networkOutHistory.append(snapshot.networkOutBps, timestamp: snapshot.timestamp)
+        diskReadHistory.append(snapshot.diskReadBps, timestamp: snapshot.timestamp)
+        diskWriteHistory.append(snapshot.diskWriteBps, timestamp: snapshot.timestamp)
+        cpuTempHistory.append(snapshot.cpuTemp, timestamp: snapshot.timestamp)
+        powerHistory.append(snapshot.systemPowerWatts, timestamp: snapshot.timestamp)
+        sampleCounter &+= 1
+    }
+}

Sources/UI/Charts/TelemetryTrendChartView.swift

@@ -0,0 +1,89 @@
+import SwiftUI
+import Charts
+
+public struct TelemetryTrendChartView: View {
+    public let title: String
+    public let unit: String
+    public let color: Color
+    public let samples: [HistoricalSample<Double>]
+    public let maxY: Double?
+    
+    public init(
+        title: String,
+        unit: String,
+        color: Color,
+        samples: [HistoricalSample<Double>],
+        maxY: Double? = nil
+    ) {
+        self.title = title
+        self.unit = unit
+        self.color = color
+        self.samples = samples
+        self.maxY = maxY
+    }
+    
+    private var currentValue: Double {
+        samples.last?.value ?? 0.0
+    }
+    
+    private var averageValue: Double {
+        guard !samples.isEmpty else { return 0.0 }
+        return samples.reduce(0.0) { $0 + $1.value } / Double(samples.count)
+    }
+    
+    private var maxValue: Double {
+        samples.map(\.value).max() ?? 0.0
+    }
+    
+    public var body: some View {
+        VStack(alignment: .leading, spacing: 10) {
+            HStack {
+                Text(title)
+                    .font(.headline)
+                Spacer()
+                HStack(spacing: 12) {
+                    Text(String(format: "Cur: %.1f %@", currentValue, unit))
+                        .font(.caption)
+                        .fontWeight(.semibold)
+                        .foregroundColor(color)
+                    Text(String(format: "Avg: %.1f %@", averageValue, unit))
+                        .font(.caption)
+                        .foregroundColor(.secondary)
+                    Text(String(format: "Max: %.1f %@", maxValue, unit))
+                        .font(.caption)
+                        .foregroundColor(.secondary)
+                }
+            }
+            
+            Chart {
+                ForEach(Array(samples.enumerated()), id: \.element.id) { index, sample in
+                    LineMark(
+                        x: .value("Sample", index),
+                        y: .value("Value", sample.value)
+                    )
+                    .interpolationMethod(.monotone)
+                    .foregroundStyle(color)
+                    
+                    AreaMark(
+                        x: .value("Sample", index),
+                        y: .value("Value", sample.value)
+                    )
+                    .interpolationMethod(.monotone)
+                    .foregroundStyle(
+                        LinearGradient(
+                            colors: [color.opacity(0.35), color.opacity(0.05)],
+                            startPoint: .top,
+                            endPoint: .bottom
+                        )
+                    )
+                }
+            }
+            .chartYScale(domain: 0...(maxY ?? max(1.0, maxValue * 1.15)))
+            .chartXAxis(.hidden)
+            .frame(height: 120)
+        }
+        .padding(14)
+        .background(Color(NSColor.controlBackgroundColor))
+        .cornerRadius(10)
+    }
+}

Sources/UI/ContentView.swift

@@ -60,6 +60,8 @@ public struct ContentView: View {
             }
             
             Section("Hardware & Devices") {
+                Label("Displays & Brightness", systemImage: "sun.max")
+                    .tag("Displays")
                 Label("Process Explorer", systemImage: "list.bullet.rectangle")
                     .tag("Processes")
                 Label("Graphics (GPU)", systemImage: "display")
@@ -70,6 +72,8 @@ public struct ContentView: View {
                     .tag("Peripherals")
                 Label("Audio Devices", systemImage: "speaker.wave.3.fill")
                     .tag("Audio")
+                Label("Historical Trends", systemImage: "chart.line.uptrend.xyaxis")
+                    .tag("Trends")
             }
         }
         .listStyle(.sidebar)
@@ -119,8 +123,12 @@ public struct ContentView: View {
                     powerCard
                 case "Peripherals":
                     peripheralsCard
+                case "Displays":
+                    displaysCard
                 case "Audio":
                     audioDevicesCard
+                case "Trends":
+                    historicalTrendsView
                 default:
                     dashboardView
                 }
@@ -153,6 +161,7 @@ public struct ContentView: View {
                 gpuTelemetryCard
                 batteryHealthCard
             }
+            displaysCard
         }
     }
     
@@ -990,6 +999,146 @@ public struct ContentView: View {
         .overlay(RoundedRectangle(cornerRadius: 12).stroke(.separator, lineWidth: 1))
     }
     
+    // MARK: - Displays Card
+    private var displaysCard: some View {
+        VStack(alignment: .leading, spacing: 14) {
+            HStack {
+                Label("Connected Displays & Brightness", systemImage: "sun.max")
+                    .font(.headline)
+                Spacer()
+                Text("\(store.displays.count) Display\(store.displays.count == 1 ? "" : "s")")
+                    .font(.caption.bold())
+                    .foregroundStyle(.secondary)
+            }
+            
+            if store.displays.isEmpty {
+                Text("No active displays detected.")
+                    .font(.caption)
+                    .foregroundStyle(.secondary)
+            } else {
+                ForEach(store.displays, id: \.displayID) { display in
+                    VStack(alignment: .leading, spacing: 8) {
+                        HStack {
+                            Image(systemName: display.isBuiltin ? "laptopcomputer" : "display")
+                                .foregroundStyle(.blue)
+                            VStack(alignment: .leading, spacing: 2) {
+                                HStack {
+                                    Text(display.name)
+                                        .font(.subheadline.bold())
+                                    if display.isMain {
+                                        Text("MAIN")
+                                            .font(.caption2.bold())
+                                            .padding(.horizontal, 6)
+                                            .padding(.vertical, 2)
+                                            .background(Color.blue.opacity(0.15), in: Capsule())
+                                    }
+                                }
+                                Text("\(display.width) × \(display.height) @ \(Int(display.refreshRate))Hz")
+                                    .font(.caption)
+                                    .foregroundStyle(.secondary)
+                            }
+                            Spacer()
+                            if display.brightness >= 0 {
+                                Text("\(Int(display.brightness * 100))%")
+                                    .font(.subheadline.bold().monospacedDigit())
+                            }
+                        }
+                        
+                        if display.brightness >= 0 {
+                            Slider(
+                                value: Binding(
+                                    get: { Double(display.brightness) },
+                                    set: { newBrightness in
+                                        _ = store.displayManager.setBrightness(Float(newBrightness), forDisplay: display.displayID)
+                                        store.triggerManualSample()
+                                    }
+                                ),
+                                in: 0.0...1.0
+                            )
+                        } else {
+                            Text("Hardware brightness control not supported for this monitor.")
+                                .font(.caption2)
+                                .foregroundStyle(.secondary)
+                        }
+                    }
+                    .padding(12)
+                    .background(.quaternary.opacity(0.5), in: RoundedRectangle(cornerRadius: 8))
+                }
+            }
+        }
+        .padding(16)
+        .background(.background, in: RoundedRectangle(cornerRadius: 12))
+        .overlay(RoundedRectangle(cornerRadius: 12).stroke(.separator, lineWidth: 1))
+    }
+    
+    // MARK: - Historical Trends View
+    private var historicalTrendsView: some View {
+        VStack(alignment: .leading, spacing: 16) {
+            TelemetryTrendChartView(
+                title: "CPU Utilization History",
+                unit: "%",
+                color: .blue,
+                samples: store.historyStore.cpuHistory.samples,
+                maxY: 100.0
+            )
+            
+            TelemetryTrendChartView(
+                title: "Memory Utilization History",
+                unit: "%",
+                color: .purple,
+                samples: store.historyStore.memoryHistory.samples,
+                maxY: 100.0
+            )
+            
+            TelemetryTrendChartView(
+                title: "CPU Temperature History",
+                unit: "°C",
+                color: .orange,
+                samples: store.historyStore.cpuTempHistory.samples,
+                maxY: 110.0
+            )
+            
+            TelemetryTrendChartView(
+                title: "System Power Draw History",
+                unit: "W",
+                color: .yellow,
+                samples: store.historyStore.powerHistory.samples
+            )
+            
+            HStack(spacing: 16) {
+                TelemetryTrendChartView(
+                    title: "Network Download Rate",
+                    unit: "B/s",
+                    color: .green,
+                    samples: store.historyStore.networkInHistory.samples
+                )
+                
+                TelemetryTrendChartView(
+                    title: "Network Upload Rate",
+                    unit: "B/s",
+                    color: .teal,
+                    samples: store.historyStore.networkOutHistory.samples
+                )
+            }
+            
+            HStack(spacing: 16) {
+                TelemetryTrendChartView(
+                    title: "Disk Read Throughput",
+                    unit: "B/s",
+                    color: .indigo,
+                    samples: store.historyStore.diskReadHistory.samples
+                )
+                
+                TelemetryTrendChartView(
+                    title: "Disk Write Throughput",
+                    unit: "B/s",
+                    color: .pink,
+                    samples: store.historyStore.diskWriteHistory.samples
+                )
+            }
+        }
+    }
+    
     // MARK: - Formatting Helpers
     private func formatBytes(_ bytes: UInt64) -> String {
         let formatter = ByteCountFormatter()

Sources/UI/MenuBar/MenuBarStatusView.swift

@@ -0,0 +1,28 @@
+import SwiftUI
+
+public struct MenuBarStatusView: View {
+    public let cpuLoad: Double
+    public let memoryPercent: Double
+    
+    public init(cpuLoad: Double, memoryPercent: Double) {
+        self.cpuLoad = cpuLoad
+        self.memoryPercent = memoryPercent
+    }
+    
+    public var body: some View {
+        HStack(spacing: 5) {
+            Image(systemName: "cpu")
+                .font(.system(size: 11))
+            Text(String(format: "%.0f%%", cpuLoad))
+                .font(.system(size: 11, weight: .medium, design: .monospaced))
+            
+            Text("•")
+                .foregroundColor(.secondary)
+            
+            Image(systemName: "memorychip")
+                .font(.system(size: 11))
+            Text(String(format: "%.0f%%", memoryPercent))
+                .font(.system(size: 11, weight: .medium, design: .monospaced))
+        }
+    }
+}

Sources/UI/MenuBar/QuickGlancePopoverView.swift

@@ -0,0 +1,134 @@
+import SwiftUI
+
+public struct QuickGlancePopoverView: View {
+    var store: SystemTelemetryStore
+    
+    public init(store: SystemTelemetryStore) {
+        self.store = store
+    }
+    
+    public var body: some View {
+        VStack(alignment: .leading, spacing: 14) {
+            // Header
+            HStack {
+                Label("MacMonitor", systemImage: "macmini")
+                    .font(.headline)
+                Spacer()
+                Button {
+                    NSApp.activate(ignoringOtherApps: true)
+                    if let window = NSApp.windows.first(where: { $0.canBecomeMain }) {
+                        window.makeKeyAndOrderFront(nil)
+                    }
+                } label: {
+                    Image(systemName: "arrow.up.right.square")
+                        .foregroundColor(.secondary)
+                }
+                .buttonStyle(.plain)
+                .help("Open Main Window")
+            }
+            
+            Divider()
+            
+            // Core Metrics Grid
+            VStack(spacing: 8) {
+                glanceRow(
+                    icon: "cpu",
+                    title: "CPU Activity",
+                    value: String(format: "%.1f%%", store.cpuLoad.totalLoad),
+                    subtitle: "\(store.logicalCpuCount) Cores"
+                )
+                
+                glanceRow(
+                    icon: "memorychip",
+                    title: "Memory",
+                    value: String(format: "%.1f%%", store.memory.utilizationPercentage),
+                    subtitle: "\(formatBytes(store.memory.usedBytes)) / \(formatBytes(store.memory.totalBytes))"
+                )
+                
+                glanceRow(
+                    icon: "thermometer.medium",
+                    title: "Thermals",
+                    value: String(format: "%.1f°C", store.cpuThermal.packageTemperature),
+                    subtitle: "Fans: \(store.fans.map { "\(Int($0.currentRPM)) RPM" }.joined(separator: ", "))"
+                )
+                
+                glanceRow(
+                    icon: "bolt.fill",
+                    title: "Power",
+                    value: String(format: "%.1f W", store.power.systemTotalWatts),
+                    subtitle: store.batteryHealth.isCharging ? "Charging (\(Int(store.batteryHealth.healthPercent))%)" : "Battery (\(Int(store.batteryHealth.healthPercent))%)"
+                )
+                
+                glanceRow(
+                    icon: "network",
+                    title: "Network",
+                    value: "↓ \(formatBps(totalDownloadBps)) / ↑ \(formatBps(totalUploadBps))",
+                    subtitle: "\(store.networkBandwidth.count) active interfaces"
+                )
+            }
+            
+            Divider()
+            
+            // Footer action
+            HStack {
+                Text("Last updated: \(store.lastUpdateTimestamp.formatted(date: .omitted, time: .standard))")
+                    .font(.caption2)
+                    .foregroundColor(.secondary)
+                Spacer()
+                Button("Quit") {
+                    NSApplication.shared.terminate(nil)
+                }
+                .font(.caption)
+            }
+        }
+        .padding(14)
+        .frame(width: 320)
+    }
+    
+    private var totalDownloadBps: Double {
+        store.networkBandwidth.reduce(0.0) { $0 + $1.downloadBps }
+    }
+    
+    private var totalUploadBps: Double {
+        store.networkBandwidth.reduce(0.0) { $0 + $1.uploadBps }
+    }
+    
+    private func glanceRow(icon: String, title: String, value: String, subtitle: String) -> some View {
+        HStack {
+            Image(systemName: icon)
+                .frame(width: 18)
+                .foregroundColor(.accentColor)
+            VStack(alignment: .leading, spacing: 2) {
+                Text(title)
+                    .font(.caption)
+                    .foregroundColor(.secondary)
+                Text(subtitle)
+                    .font(.caption2)
+                    .foregroundColor(.secondary)
+                    .lineLimit(1)
+            }
+            Spacer()
+            Text(value)
+                .font(.subheadline)
+                .fontWeight(.semibold)
+                .fontDesign(.monospaced)
+        }
+    }
+    
+    private func formatBytes(_ bytes: UInt64) -> String {
+        let formatter = ByteCountFormatter()
+        formatter.allowedUnits = [.useAll]
+        formatter.countStyle = .memory
+        return formatter.string(fromByteCount: Int64(bytes))
+    }
+    
+    private func formatBps(_ bps: Double) -> String {
+        if bps < 1024 {
+            return String(format: "%.0f B/s", bps)
+        } else if bps < 1024 * 1024 {
+            return String(format: "%.1f KB/s", bps / 1024)
+        } else {
+            return String(format: "%.2f MB/s", bps / (1024 * 1024))
+        }
+    }
+}

Tests/MMHistoryTests.swift

@@ -0,0 +1,54 @@
+import XCTest
+@testable import MacMonitor
+
+final class MMHistoryTests: XCTestCase {
+    
+    func testRollingRingBufferCapacityAndEviction() {
+        let buffer = RollingRingBuffer<Double>(capacity: 3)
+        XCTAssertEqual(buffer.count, 0)
+        
+        buffer.append(10.0)
+        buffer.append(20.0)
+        XCTAssertEqual(buffer.count, 2)
+        XCTAssertEqual(buffer.samples.map(\.value), [10.0, 20.0])
+        
+        buffer.append(30.0)
+        XCTAssertEqual(buffer.count, 3)
+        XCTAssertEqual(buffer.samples.map(\.value), [10.0, 20.0, 30.0])
+        
+        // 4th append should evict oldest (10.0)
+        buffer.append(40.0)
+        XCTAssertEqual(buffer.count, 3)
+        XCTAssertEqual(buffer.samples.map(\.value), [20.0, 30.0, 40.0])
+        
+        buffer.clear()
+        XCTAssertEqual(buffer.count, 0)
+        XCTAssertTrue(buffer.samples.isEmpty)
+    }
+    
+    func testTelemetryHistoryStoreRecord() {
+        let store = TelemetryHistoryStore()
+        let snapshot = TelemetrySnapshotRecord(
+            cpuLoad: 25.5,
+            memoryUsedPercent: 62.1,
+            networkInBps: 1024.0,
+            networkOutBps: 2048.0,
+            diskReadBps: 512.0,
+            diskWriteBps: 1024.0,
+            cpuTemp: 55.0,
+            systemPowerWatts: 18.5
+        )
+        store.record(snapshot: snapshot)
+        
+        XCTAssertEqual(store.sampleCounter, 1)
+        XCTAssertEqual(store.cpuHistory.count, 1)
+        XCTAssertEqual(store.cpuHistory.samples.first?.value, 25.5)
+        XCTAssertEqual(store.memoryHistory.samples.first?.value, 62.1)
+        XCTAssertEqual(store.networkInHistory.samples.first?.value, 1024.0)
+        XCTAssertEqual(store.networkOutHistory.samples.first?.value, 2048.0)
+        XCTAssertEqual(store.diskReadHistory.samples.first?.value, 512.0)
+        XCTAssertEqual(store.diskWriteHistory.samples.first?.value, 1024.0)
+        XCTAssertEqual(store.cpuTempHistory.samples.first?.value, 55.0)
+        XCTAssertEqual(store.powerHistory.samples.first?.value, 18.5)
+    }
+}

Tests/MMMenuBarTests.swift

@@ -0,0 +1,18 @@
+import XCTest
+import SwiftUI
+@testable import MacMonitor
+
+final class MMMenuBarTests: XCTestCase {
+    
+    func testMenuBarStatusViewInitialization() {
+        let view = MenuBarStatusView(cpuLoad: 24.5, memoryPercent: 55.0)
+        XCTAssertEqual(view.cpuLoad, 24.5)
+        XCTAssertEqual(view.memoryPercent, 55.0)
+    }
+    
+    func testQuickGlancePopoverViewInitialization() {
+        let store = SystemTelemetryStore.shared
+        let view = QuickGlancePopoverView(store: store)
+        XCTAssertNotNil(view)
+    }
+}