@lattices/cli 0.4.2 → 0.4.6

package/app/Sources/Core/System/SystemTelemetryMonitor.swift

@@ -0,0 +1,273 @@
+import DeckKit
+import Foundation
+import IOKit
+import IOKit.ps
+
+final class SystemTelemetryMonitor {
+    static let shared = SystemTelemetryMonitor()
+
+    private struct CPUTicks {
+        var user: UInt64
+        var system: UInt64
+        var idle: UInt64
+        var nice: UInt64
+
+        var total: UInt64 {
+            user + system + idle + nice
+        }
+    }
+
+    private struct BatterySample {
+        var percent: Double?
+        var isCharging: Bool?
+        var powerSource: String?
+    }
+
+    private struct CoreSample {
+        var sampledAt: Date
+        var cpuLoadPercent: Double?
+        var memoryUsedPercent: Double?
+        var gpuLoadPercent: Double?
+        var thermalPressurePercent: Double?
+        var thermalState: DeckThermalState?
+        var temperatureCelsius: Double?
+        var batteryPercent: Double?
+        var isCharging: Bool?
+        var powerSource: String?
+    }
+
+    private let lock = NSLock()
+    private var previousCPUTicks: [CPUTicks]?
+    private var cachedSample: CoreSample?
+    private var cachedAt: Date = .distantPast
+    private let minSampleInterval: TimeInterval = 0.8
+
+    private init() {}
+
+    func snapshot(windowCount: Int, sessionCount: Int) -> DeckSystemTelemetry {
+        let core = currentCoreSample()
+        return DeckSystemTelemetry(
+            sampledAt: core.sampledAt,
+            cpuLoadPercent: core.cpuLoadPercent,
+            memoryUsedPercent: core.memoryUsedPercent,
+            gpuLoadPercent: core.gpuLoadPercent,
+            thermalPressurePercent: core.thermalPressurePercent,
+            thermalState: core.thermalState,
+            temperatureCelsius: core.temperatureCelsius,
+            batteryPercent: core.batteryPercent,
+            isCharging: core.isCharging,
+            powerSource: core.powerSource,
+            windowCount: windowCount,
+            sessionCount: sessionCount
+        )
+    }
+}
+
+private extension SystemTelemetryMonitor {
+    private func currentCoreSample() -> CoreSample {
+        lock.lock()
+        defer { lock.unlock() }
+
+        let now = Date()
+        if let cachedSample, now.timeIntervalSince(cachedAt) < minSampleInterval {
+            return cachedSample
+        }
+
+        let thermal = readThermalState()
+        let battery = readBattery()
+        let sample = CoreSample(
+            sampledAt: now,
+            cpuLoadPercent: readCPULoadPercent(),
+            memoryUsedPercent: readMemoryUsedPercent(),
+            gpuLoadPercent: readGPULoadPercent(),
+            thermalPressurePercent: thermal.pressure,
+            thermalState: thermal.state,
+            temperatureCelsius: nil,
+            batteryPercent: battery.percent,
+            isCharging: battery.isCharging,
+            powerSource: battery.powerSource
+        )
+        cachedSample = sample
+        cachedAt = now
+        return sample
+    }
+
+    func readCPULoadPercent() -> Double? {
+        var cpuInfo: processor_info_array_t?
+        var processorCount: natural_t = 0
+        var infoCount: mach_msg_type_number_t = 0
+
+        let result = host_processor_info(
+            mach_host_self(),
+            PROCESSOR_CPU_LOAD_INFO,
+            &processorCount,
+            &cpuInfo,
+            &infoCount
+        )
+        guard result == KERN_SUCCESS, let cpuInfo else {
+            return nil
+        }
+
+        defer {
+            let size = vm_size_t(Int(infoCount) * MemoryLayout<integer_t>.stride)
+            vm_deallocate(mach_task_self_, vm_address_t(UInt(bitPattern: cpuInfo)), size)
+        }
+
+        let statesPerCPU = Int(CPU_STATE_MAX)
+        let info = UnsafeBufferPointer(start: cpuInfo, count: Int(infoCount))
+        let ticks: [CPUTicks] = (0..<Int(processorCount)).map { index in
+            let offset = index * statesPerCPU
+            return CPUTicks(
+                user: cpuTick(info[offset + Int(CPU_STATE_USER)]),
+                system: cpuTick(info[offset + Int(CPU_STATE_SYSTEM)]),
+                idle: cpuTick(info[offset + Int(CPU_STATE_IDLE)]),
+                nice: cpuTick(info[offset + Int(CPU_STATE_NICE)])
+            )
+        }
+
+        guard !ticks.isEmpty else { return nil }
+
+        defer { previousCPUTicks = ticks }
+
+        guard let previousCPUTicks, previousCPUTicks.count == ticks.count else {
+            let total = ticks.reduce(UInt64(0)) { $0 + $1.total }
+            let idle = ticks.reduce(UInt64(0)) { $0 + $1.idle }
+            guard total > 0 else { return nil }
+            return clampPercent(100.0 * Double(total - idle) / Double(total))
+        }
+
+        var busyDelta: UInt64 = 0
+        var totalDelta: UInt64 = 0
+        for (current, previous) in zip(ticks, previousCPUTicks) {
+            let total = current.total.saturatingSubtract(previous.total)
+            let idle = current.idle.saturatingSubtract(previous.idle)
+            totalDelta += total
+            busyDelta += total.saturatingSubtract(idle)
+        }
+
+        guard totalDelta > 0 else { return nil }
+        return clampPercent(100.0 * Double(busyDelta) / Double(totalDelta))
+    }
+
+    func readMemoryUsedPercent() -> Double? {
+        var stats = vm_statistics64()
+        var count = mach_msg_type_number_t(MemoryLayout<vm_statistics64_data_t>.stride / MemoryLayout<integer_t>.stride)
+
+        let result = withUnsafeMutablePointer(to: &stats) {
+            $0.withMemoryRebound(to: integer_t.self, capacity: Int(count)) {
+                host_statistics64(mach_host_self(), HOST_VM_INFO64, $0, &count)
+            }
+        }
+        guard result == KERN_SUCCESS else { return nil }
+
+        var pageSize = vm_size_t()
+        host_page_size(mach_host_self(), &pageSize)
+
+        let freePages = UInt64(stats.free_count) + UInt64(stats.speculative_count)
+        let freeBytes = freePages * UInt64(pageSize)
+        let totalBytes = ProcessInfo.processInfo.physicalMemory
+        guard totalBytes > 0 else { return nil }
+
+        let usedBytes = totalBytes > freeBytes ? totalBytes - freeBytes : 0
+        return clampPercent(100.0 * Double(usedBytes) / Double(totalBytes))
+    }
+
+    func readGPULoadPercent() -> Double? {
+        guard let matching = IOServiceMatching("IOAccelerator") else {
+            return nil
+        }
+
+        var iterator: io_iterator_t = 0
+        guard IOServiceGetMatchingServices(kIOMainPortDefault, matching, &iterator) == KERN_SUCCESS else {
+            return nil
+        }
+        defer { IOObjectRelease(iterator) }
+
+        var values: [Double] = []
+        while true {
+            let service = IOIteratorNext(iterator)
+            if service == 0 { break }
+            defer { IOObjectRelease(service) }
+
+            guard let unmanaged = IORegistryEntryCreateCFProperty(
+                service,
+                "PerformanceStatistics" as CFString,
+                kCFAllocatorDefault,
+                0
+            ) else {
+                continue
+            }
+
+            guard let stats = unmanaged.takeRetainedValue() as? [String: Any] else {
+                continue
+            }
+
+            for key in ["Device Utilization %", "Renderer Utilization %"] {
+                if let number = stats[key] as? NSNumber {
+                    values.append(number.doubleValue)
+                }
+            }
+        }
+
+        guard !values.isEmpty else { return nil }
+        return clampPercent(values.reduce(0, +) / Double(values.count))
+    }
+
+    func readThermalState() -> (state: DeckThermalState, pressure: Double) {
+        switch ProcessInfo.processInfo.thermalState {
+        case .nominal:
+            return (.nominal, 10)
+        case .fair:
+            return (.fair, 35)
+        case .serious:
+            return (.serious, 70)
+        case .critical:
+            return (.critical, 100)
+        @unknown default:
+            return (.nominal, 10)
+        }
+    }
+
+    private func readBattery() -> BatterySample {
+        let powerInfo = IOPSCopyPowerSourcesInfo().takeRetainedValue()
+        let sourceList = IOPSCopyPowerSourcesList(powerInfo).takeRetainedValue() as [CFTypeRef]
+
+        for source in sourceList {
+            guard let description = IOPSGetPowerSourceDescription(powerInfo, source)?
+                .takeUnretainedValue() as? [String: Any] else {
+                continue
+            }
+
+            let current = description[kIOPSCurrentCapacityKey] as? Int
+            let max = description[kIOPSMaxCapacityKey] as? Int
+            let percent = current.flatMap { current in
+                max.flatMap { maxValue -> Double? in
+                    guard maxValue > 0 else { return nil }
+                    return clampPercent(100.0 * Double(current) / Double(maxValue))
+                }
+            }
+
+            return BatterySample(
+                percent: percent,
+                isCharging: description[kIOPSIsChargingKey] as? Bool,
+                powerSource: description[kIOPSPowerSourceStateKey] as? String
+            )
+        }
+
+        return BatterySample(percent: nil, isCharging: nil, powerSource: nil)
+    }
+
+    func clampPercent(_ value: Double) -> Double {
+        max(0, min(100, value))
+    }
+
+    func cpuTick(_ value: integer_t) -> UInt64 {
+        UInt64(UInt32(bitPattern: value))
+    }
+}
+
+private extension UInt64 {
+    func saturatingSubtract(_ other: UInt64) -> UInt64 {
+        self > other ? self - other : 0
+    }
+}

package/app/Sources/{HandsOffSession.swift → Core/Voice/HandsOffSession.swift}

@@ -43,7 +43,14 @@ final class HandsOffSession: ObservableObject {
         case thinking
     }
 
-    @Published var state: State = .idle
+    @Published var state: State = .idle {
+        didSet {
+            if state != oldValue {
+                stateChangedAt = Date()
+            }
+        }
+    }
+    @Published private(set) var stateChangedAt: Date = Date()
     @Published var lastTranscript: String?
     @Published var lastResponse: String?
     @Published var audibleFeedbackEnabled: Bool = false
@@ -58,6 +65,7 @@ final class HandsOffSession: ObservableObject {
         let frame: WindowFrame
     }
     private(set) var frameHistory: [FrameSnapshot] = []
+    private(set) var frameHistoryUpdatedAt: Date?
 
     /// Snapshot current frames for all windows that are about to be moved.
     /// Stores frames in CG/AX coordinates (top-left origin) for direct use with batchRestoreWindows.
@@ -77,10 +85,12 @@ final class HandsOffSession: ObservableObject {
                 break
             }
         }
+        frameHistoryUpdatedAt = frameHistory.isEmpty ? nil : Date()
     }
 
     func clearFrameHistory() {
         frameHistory.removeAll()
+        frameHistoryUpdatedAt = nil
     }
 
     /// Running chat log — visible in the voice chat panel. Persists across turns.
@@ -327,7 +337,9 @@ final class HandsOffSession: ObservableObject {
                 }
             }
 
-            // Single dispatch — all @Published mutations in one block
+            // Single dispatch — all @Published mutations in one block.
+            // The pending callback also mutates @Published state, so it must
+            // run on main with the rest of the turn completion.
             DispatchQueue.main.async { [weak self] in
                 guard let self else { return }
                 if let spoken { self.lastResponse = spoken }
@@ -342,9 +354,8 @@ final class HandsOffSession: ObservableObject {
                     self.executeActions(actions)
                 }
                 self.state = .idle
+                cb?(json)
             }
-
-            cb?(json)
         }
     }
 

package/app/Sources/{WorkspaceManager.swift → Core/Workspace/WorkspaceManager.swift}

@@ -63,6 +63,273 @@ struct LayoutConfig: Codable {
 struct GridFile: Codable {
     let presets: [String: GridPreset]?
     let layouts: [String: LayoutConfig]?
+    let snapZones: SnapZonesConfig?
+}
+
+enum SnapModifierKey: String, Codable, Equatable {
+    case command
+    case option
+    case control
+    case shift
+
+    var eventFlags: NSEvent.ModifierFlags {
+        switch self {
+        case .command:
+            return .command
+        case .option:
+            return .option
+        case .control:
+            return .control
+        case .shift:
+            return .shift
+        }
+    }
+
+    var cgEventFlags: CGEventFlags {
+        switch self {
+        case .command:
+            return .maskCommand
+        case .option:
+            return .maskAlternate
+        case .control:
+            return .maskControl
+        case .shift:
+            return .maskShift
+        }
+    }
+
+    var label: String {
+        rawValue.capitalized
+    }
+}
+
+enum SnapZoneTriggerSpec: Codable, Equatable {
+    case named(String)
+    case fractions(FractionalPlacement)
+
+    init(from decoder: Decoder) throws {
+        let container = try decoder.singleValueContainer()
+        if let named = try? container.decode(String.self) {
+            self = .named(named)
+            return
+        }
+
+        let preset = try container.decode(GridPreset.self)
+        guard let placement = FractionalPlacement(x: preset.x, y: preset.y, w: preset.w, h: preset.h) else {
+            throw DecodingError.dataCorruptedError(
+                in: container,
+                debugDescription: "snap zone trigger fractions must stay within 0...1"
+            )
+        }
+        self = .fractions(placement)
+    }
+
+    func encode(to encoder: Encoder) throws {
+        var container = encoder.singleValueContainer()
+        switch self {
+        case .named(let name):
+            try container.encode(name)
+        case .fractions(let placement):
+            try container.encode(GridPreset(x: placement.x, y: placement.y, w: placement.w, h: placement.h))
+        }
+    }
+}
+
+enum SnapZonePlacementSpec: Codable, Equatable {
+    case named(String)
+    case fractions(FractionalPlacement)
+
+    init(from decoder: Decoder) throws {
+        let container = try decoder.singleValueContainer()
+        if let named = try? container.decode(String.self) {
+            self = .named(named)
+            return
+        }
+
+        let preset = try container.decode(GridPreset.self)
+        guard let placement = FractionalPlacement(x: preset.x, y: preset.y, w: preset.w, h: preset.h) else {
+            throw DecodingError.dataCorruptedError(
+                in: container,
+                debugDescription: "snap zone placement fractions must stay within 0...1"
+            )
+        }
+        self = .fractions(placement)
+    }
+
+    func encode(to encoder: Encoder) throws {
+        var container = encoder.singleValueContainer()
+        switch self {
+        case .named(let name):
+            try container.encode(name)
+        case .fractions(let placement):
+            try container.encode(GridPreset(x: placement.x, y: placement.y, w: placement.w, h: placement.h))
+        }
+    }
+}
+
+struct SnapZoneDefinition: Codable, Equatable, Identifiable {
+    let rawID: String?
+    let label: String?
+    let placement: SnapZonePlacementSpec
+    let trigger: SnapZoneTriggerSpec
+    let priority: Int?
+
+    enum CodingKeys: String, CodingKey {
+        case rawID = "id"
+        case label
+        case placement
+        case trigger
+        case priority
+    }
+
+    var id: String {
+        let trimmed = rawID?.trimmingCharacters(in: .whitespacesAndNewlines) ?? ""
+        return trimmed.isEmpty ? fallbackID : trimmed
+    }
+
+    private var fallbackID: String {
+        switch placement {
+        case .named(let name):
+            return name
+        case .fractions(let fractions):
+            return "fractions-\(fractions.x)-\(fractions.y)-\(fractions.w)-\(fractions.h)"
+        }
+    }
+}
+
+struct SnapZonesConfig: Codable, Equatable {
+    let enabled: Bool?
+    let modifier: SnapModifierKey?
+    let zoneOpacity: Double?
+    let highlightOpacity: Double?
+    let previewOpacity: Double?
+    let cornerRadius: CGFloat?
+    let rules: [SnapZoneDefinition]?
+
+    enum CodingKeys: String, CodingKey {
+        case enabled
+        case modifier
+        case zoneOpacity
+        case highlightOpacity
+        case previewOpacity
+        case cornerRadius
+        case rules
+        case zones
+    }
+
+    init(
+        enabled: Bool?,
+        modifier: SnapModifierKey?,
+        zoneOpacity: Double?,
+        highlightOpacity: Double?,
+        previewOpacity: Double?,
+        cornerRadius: CGFloat?,
+        rules: [SnapZoneDefinition]?
+    ) {
+        self.enabled = enabled
+        self.modifier = modifier
+        self.zoneOpacity = zoneOpacity
+        self.highlightOpacity = highlightOpacity
+        self.previewOpacity = previewOpacity
+        self.cornerRadius = cornerRadius
+        self.rules = rules
+    }
+
+    init(from decoder: Decoder) throws {
+        let container = try decoder.container(keyedBy: CodingKeys.self)
+        enabled = try container.decodeIfPresent(Bool.self, forKey: .enabled)
+        modifier = try container.decodeIfPresent(SnapModifierKey.self, forKey: .modifier)
+        zoneOpacity = try container.decodeIfPresent(Double.self, forKey: .zoneOpacity)
+        highlightOpacity = try container.decodeIfPresent(Double.self, forKey: .highlightOpacity)
+        previewOpacity = try container.decodeIfPresent(Double.self, forKey: .previewOpacity)
+        cornerRadius = try container.decodeIfPresent(CGFloat.self, forKey: .cornerRadius)
+        let decodedRules = try container.decodeIfPresent([SnapZoneDefinition].self, forKey: .rules)
+        let decodedZones = try container.decodeIfPresent([SnapZoneDefinition].self, forKey: .zones)
+        rules = decodedRules ?? decodedZones
+    }
+
+    func encode(to encoder: Encoder) throws {
+        var container = encoder.container(keyedBy: CodingKeys.self)
+        try container.encodeIfPresent(enabled, forKey: .enabled)
+        try container.encodeIfPresent(modifier, forKey: .modifier)
+        try container.encodeIfPresent(zoneOpacity, forKey: .zoneOpacity)
+        try container.encodeIfPresent(highlightOpacity, forKey: .highlightOpacity)
+        try container.encodeIfPresent(previewOpacity, forKey: .previewOpacity)
+        try container.encodeIfPresent(cornerRadius, forKey: .cornerRadius)
+        try container.encodeIfPresent(rules, forKey: .rules)
+    }
+
+    static let defaults = SnapZonesConfig(
+        enabled: true,
+        modifier: .command,
+        zoneOpacity: 0.10,
+        highlightOpacity: 0.22,
+        previewOpacity: 0.18,
+        cornerRadius: 18,
+        rules: [
+            SnapZoneDefinition(
+                rawID: "top-left",
+                label: "Top Left",
+                placement: .named("top-left"),
+                trigger: .fractions(FractionalPlacement(x: 0.00, y: 0.00, w: 0.24, h: 0.18)!),
+                priority: 40
+            ),
+            SnapZoneDefinition(
+                rawID: "maximize",
+                label: "Maximize",
+                placement: .named("maximize"),
+                trigger: .fractions(FractionalPlacement(x: 0.24, y: 0.00, w: 0.52, h: 0.12)!),
+                priority: 20
+            ),
+            SnapZoneDefinition(
+                rawID: "top-right",
+                label: "Top Right",
+                placement: .named("top-right"),
+                trigger: .fractions(FractionalPlacement(x: 0.76, y: 0.00, w: 0.24, h: 0.18)!),
+                priority: 40
+            ),
+            SnapZoneDefinition(
+                rawID: "left",
+                label: "Left",
+                placement: .named("left"),
+                trigger: .fractions(FractionalPlacement(x: 0.00, y: 0.18, w: 0.12, h: 0.64)!),
+                priority: 10
+            ),
+            SnapZoneDefinition(
+                rawID: "right",
+                label: "Right",
+                placement: .named("right"),
+                trigger: .fractions(FractionalPlacement(x: 0.88, y: 0.18, w: 0.12, h: 0.64)!),
+                priority: 10
+            ),
+            SnapZoneDefinition(
+                rawID: "bottom-left",
+                label: "Bottom Left",
+                placement: .named("bottom-left"),
+                trigger: .fractions(FractionalPlacement(x: 0.00, y: 0.82, w: 0.24, h: 0.18)!),
+                priority: 40
+            ),
+            SnapZoneDefinition(
+                rawID: "bottom-right",
+                label: "Bottom Right",
+                placement: .named("bottom-right"),
+                trigger: .fractions(FractionalPlacement(x: 0.76, y: 0.82, w: 0.24, h: 0.18)!),
+                priority: 40
+            ),
+        ]
+    )
+
+    func merged(over defaults: SnapZonesConfig = .defaults) -> SnapZonesConfig {
+        SnapZonesConfig(
+            enabled: enabled ?? defaults.enabled,
+            modifier: modifier ?? defaults.modifier,
+            zoneOpacity: zoneOpacity ?? defaults.zoneOpacity,
+            highlightOpacity: highlightOpacity ?? defaults.highlightOpacity,
+            previewOpacity: previewOpacity ?? defaults.previewOpacity,
+            cornerRadius: cornerRadius ?? defaults.cornerRadius,
+            rules: rules ?? defaults.rules
+        )
+    }
 }
 
 // MARK: - Manager
@@ -75,9 +342,11 @@ class WorkspaceManager: ObservableObject {
     @Published var isSwitching: Bool = false
     @Published var gridPresets: [String: GridPreset] = [:]
     @Published var gridLayouts: [String: LayoutConfig] = [:]
+    @Published var snapZonesConfig: SnapZonesConfig = .defaults
 
     private let configPath: String
     private let gridConfigPath: String
+    private let snapZonesConfigPath: String
     private var tmuxPath: String { TmuxQuery.resolvedPath ?? "/opt/homebrew/bin/tmux" }
     private let activeLayerKey = "lattices.activeLayerIndex"
 
@@ -85,6 +354,7 @@ class WorkspaceManager: ObservableObject {
         let home = FileManager.default.homeDirectoryForCurrentUser.path
         self.configPath = (home as NSString).appendingPathComponent(".lattices/workspace.json")
         self.gridConfigPath = (home as NSString).appendingPathComponent(".lattices/grid.json")
+        self.snapZonesConfigPath = (home as NSString).appendingPathComponent(".lattices/snap-zones.json")
         self.activeLayerIndex = UserDefaults.standard.integer(forKey: activeLayerKey)
         loadConfig()
         loadGridConfig()
@@ -137,6 +407,7 @@ class WorkspaceManager: ObservableObject {
     func loadGridConfig() {
         var presets: [String: GridPreset] = [:]
         var layouts: [String: LayoutConfig] = [:]
+        var snapZones = SnapZonesConfig.defaults
 
         // Load global ~/.lattices/grid.json
         if FileManager.default.fileExists(atPath: gridConfigPath),
@@ -145,11 +416,24 @@ class WorkspaceManager: ObservableObject {
                 let gridFile = try JSONDecoder().decode(GridFile.self, from: data)
                 if let p = gridFile.presets { presets.merge(p) { _, new in new } }
                 if let l = gridFile.layouts { layouts.merge(l) { _, new in new } }
+                if let snap = gridFile.snapZones {
+                    snapZones = snap.merged(over: snapZones)
+                }
             } catch {
                 DiagnosticLog.shared.error("WorkspaceManager: failed to decode grid.json — \(error.localizedDescription)")
             }
         }
 
+        if FileManager.default.fileExists(atPath: snapZonesConfigPath),
+           let data = FileManager.default.contents(atPath: snapZonesConfigPath) {
+            do {
+                let config = try JSONDecoder().decode(SnapZonesConfig.self, from: data)
+                snapZones = config.merged(over: snapZones)
+            } catch {
+                DiagnosticLog.shared.error("WorkspaceManager: failed to decode snap-zones.json — \(error.localizedDescription)")
+            }
+        }
+
         // Merge per-project .lattices.json "grid" section on top
         let projectGridPath = ".lattices.json"
         if FileManager.default.fileExists(atPath: projectGridPath),
@@ -161,6 +445,9 @@ class WorkspaceManager: ObservableObject {
                     let gridFile = try JSONDecoder().decode(GridFile.self, from: gridData)
                     if let p = gridFile.presets { presets.merge(p) { _, new in new } }
                     if let l = gridFile.layouts { layouts.merge(l) { _, new in new } }
+                    if let snap = gridFile.snapZones {
+                        snapZones = snap.merged(over: snapZones)
+                    }
                 }
             } catch {
                 DiagnosticLog.shared.error("WorkspaceManager: failed to decode .lattices.json grid — \(error.localizedDescription)")
@@ -169,6 +456,7 @@ class WorkspaceManager: ObservableObject {
 
         self.gridPresets = presets
         self.gridLayouts = layouts
+        self.snapZonesConfig = snapZones
     }
 
     /// Resolve a tile string to fractions: check user presets first, then built-in TilePosition