@lattices/cli 0.4.2 → 0.4.6

package/app/Sources/Core/Desktop/WindowPreviewCard.swift

@@ -0,0 +1,100 @@
+import AppKit
+import SwiftUI
+
+struct WindowPreviewCardStyle {
+    var containerCornerRadius: CGFloat = 10
+    var imageCornerRadius: CGFloat = 8
+    var imagePadding: CGFloat = 8
+    var background: Color = Palette.surface.opacity(0.8)
+    var border: Color = Palette.border
+}
+
+struct WindowPreviewCard<Overlay: View>: View {
+    let image: NSImage?
+    let isLoading: Bool
+    let appName: String
+    var loadingTitle: String = "Capturing preview"
+    var unavailableTitle: String = "Preview unavailable"
+    var style: WindowPreviewCardStyle = WindowPreviewCardStyle()
+    var holdingPreviousPreview: Bool = false
+    @ViewBuilder let overlay: () -> Overlay
+
+    var body: some View {
+        ZStack {
+            RoundedRectangle(cornerRadius: style.containerCornerRadius)
+                .fill(style.background)
+                .overlay(
+                    RoundedRectangle(cornerRadius: style.containerCornerRadius)
+                        .strokeBorder(style.border, lineWidth: 0.5)
+                )
+
+            if let image {
+                Image(nsImage: image)
+                    .resizable()
+                    .aspectRatio(contentMode: .fit)
+                    .clipShape(RoundedRectangle(cornerRadius: style.imageCornerRadius))
+                    .padding(style.imagePadding)
+                    .opacity(holdingPreviousPreview ? 0.88 : 1)
+            } else if isLoading {
+                WindowPreviewPlaceholder(
+                    icon: "photo",
+                    title: loadingTitle,
+                    subtitle: appName
+                )
+            } else {
+                WindowPreviewPlaceholder(
+                    icon: "eye.slash",
+                    title: unavailableTitle,
+                    subtitle: appName
+                )
+            }
+
+            overlay()
+        }
+    }
+}
+
+extension WindowPreviewCard where Overlay == EmptyView {
+    init(
+        image: NSImage?,
+        isLoading: Bool,
+        appName: String,
+        loadingTitle: String = "Capturing preview",
+        unavailableTitle: String = "Preview unavailable",
+        style: WindowPreviewCardStyle = WindowPreviewCardStyle(),
+        holdingPreviousPreview: Bool = false
+    ) {
+        self.init(
+            image: image,
+            isLoading: isLoading,
+            appName: appName,
+            loadingTitle: loadingTitle,
+            unavailableTitle: unavailableTitle,
+            style: style,
+            holdingPreviousPreview: holdingPreviousPreview,
+            overlay: { EmptyView() }
+        )
+    }
+}
+
+private struct WindowPreviewPlaceholder: View {
+    let icon: String
+    let title: String
+    let subtitle: String
+
+    var body: some View {
+        VStack(spacing: 8) {
+            Image(systemName: icon)
+                .font(.system(size: 18, weight: .medium))
+                .foregroundColor(Palette.textMuted.opacity(0.7))
+            Text(title)
+                .font(Typo.monoBold(10))
+                .foregroundColor(Palette.textMuted)
+            Text(subtitle)
+                .font(Typo.mono(9))
+                .foregroundColor(Palette.textDim)
+                .lineLimit(1)
+        }
+        .padding(16)
+    }
+}

package/app/Sources/Core/Desktop/WindowPreviewStore.swift

@@ -0,0 +1,113 @@
+import AppKit
+import SwiftUI
+
+final class WindowPreviewStore: ObservableObject {
+    static let shared = WindowPreviewStore()
+
+    @Published private var images: [UInt32: NSImage] = [:]
+    @Published private var loading: Set<UInt32> = []
+
+    private var lastAttemptAt: [UInt32: Date] = [:]
+    private var accessOrder: [UInt32] = []
+    private let maxCached = 15
+    private let queue = DispatchQueue(label: "com.arach.lattices.window-preview", qos: .userInitiated)
+    private let previewMaxSize = NSSize(width: 360, height: 190)
+
+    func image(for wid: UInt32) -> NSImage? {
+        if images[wid] != nil {
+            touchLRU(wid)
+        }
+        return images[wid]
+    }
+
+    func hasSettled(_ wid: UInt32) -> Bool {
+        images[wid] != nil || (lastAttemptAt[wid] != nil && !loading.contains(wid))
+    }
+
+    func isLoading(_ wid: UInt32) -> Bool {
+        loading.contains(wid)
+    }
+
+    func prewarm(windows: [WindowEntry], limit: Int = 4) {
+        for window in windows.prefix(limit) {
+            load(window: window)
+        }
+    }
+
+    func load(window: WindowEntry) {
+        if images[window.wid] != nil || loading.contains(window.wid) {
+            return
+        }
+
+        let now = Date()
+        if let lastAttemptAt = lastAttemptAt[window.wid], now.timeIntervalSince(lastAttemptAt) < 1.0 {
+            return
+        }
+        lastAttemptAt[window.wid] = now
+
+        loading.insert(window.wid)
+        let wid = window.wid
+        let frame = window.frame
+        let startedAt = Date()
+
+        queue.async { [weak self] in
+            guard let self else { return }
+
+            let cgImage = CGWindowListCreateImage(
+                .null,
+                .optionIncludingWindow,
+                CGWindowID(wid),
+                [.boundsIgnoreFraming, .nominalResolution]
+            )
+
+            let image = cgImage.map {
+                NSImage(
+                    cgImage: $0,
+                    size: self.previewSize(for: frame)
+                )
+            }
+
+            DispatchQueue.main.async {
+                self.loading.remove(wid)
+                let elapsedMs = Int(Date().timeIntervalSince(startedAt) * 1000)
+                if let image {
+                    self.images[wid] = image
+                    self.touchLRU(wid)
+                    self.evictIfNeeded()
+                    if elapsedMs >= 80 {
+                        DiagnosticLog.shared.info("HUDPreview: captured wid=\(wid) in \(elapsedMs)ms")
+                    }
+                } else {
+                    DiagnosticLog.shared.info("HUDPreview: capture unavailable wid=\(wid) after \(elapsedMs)ms")
+                }
+            }
+        }
+    }
+
+    private func touchLRU(_ wid: UInt32) {
+        accessOrder.removeAll { $0 == wid }
+        accessOrder.append(wid)
+    }
+
+    private func evictIfNeeded() {
+        while images.count > maxCached, let oldest = accessOrder.first {
+            accessOrder.removeFirst()
+            images.removeValue(forKey: oldest)
+            lastAttemptAt.removeValue(forKey: oldest)
+        }
+    }
+
+    private func previewSize(for frame: WindowFrame) -> NSSize {
+        let width = max(CGFloat(frame.w), CGFloat(1))
+        let height = max(CGFloat(frame.h), CGFloat(1))
+        let scale = min(
+            previewMaxSize.width / width,
+            previewMaxSize.height / height,
+            CGFloat(1)
+        )
+        return NSSize(
+            width: max(CGFloat(1), width * scale),
+            height: max(CGFloat(1), height * scale)
+        )
+    }
+}

package/app/Sources/Core/Desktop/WindowSelectionStore.swift

@@ -0,0 +1,76 @@
+import Combine
+import Foundation
+
+struct SelectedWindowSummary: Identifiable, Equatable {
+    let wid: UInt32
+    let app: String
+    let title: String
+    let latticesSession: String?
+
+    var id: UInt32 { wid }
+
+    var displayTitle: String {
+        if !title.isEmpty { return title }
+        if let latticesSession, !latticesSession.isEmpty { return latticesSession }
+        return app
+    }
+}
+
+final class WindowSelectionStore: ObservableObject {
+    static let shared = WindowSelectionStore()
+
+    @Published private(set) var windows: [SelectedWindowSummary] = []
+    @Published private(set) var source: String?
+    @Published private(set) var updatedAt: Date?
+
+    private init() {}
+
+    var isActive: Bool { !windows.isEmpty }
+    var windowIds: [UInt32] { windows.map(\.wid) }
+    var count: Int { windows.count }
+    var sourceLabel: String? {
+        switch source {
+        case "desktop-inventory": return "window selector"
+        case "screen-map": return "screen map"
+        case let value?: return value
+        case nil: return nil
+        }
+    }
+
+    func setSelection(_ windows: [SelectedWindowSummary], source: String) {
+        let unique = Array(
+            Dictionary(uniqueKeysWithValues: windows.map { ($0.wid, $0) }).values
+        ).sorted { lhs, rhs in
+            if lhs.app == rhs.app { return lhs.wid < rhs.wid }
+            return lhs.app.localizedCaseInsensitiveCompare(rhs.app) == .orderedAscending
+        }
+
+        DispatchQueue.main.async {
+            self.windows = unique
+            self.source = source
+            self.updatedAt = Date()
+        }
+    }
+
+    func clear(source: String? = nil) {
+        DispatchQueue.main.async {
+            if let source, let current = self.source, current != source {
+                return
+            }
+            self.windows = []
+            self.source = source ?? self.source
+            self.updatedAt = Date()
+        }
+    }
+
+    func summary(maxItems: Int = 3) -> String {
+        guard !windows.isEmpty else { return "No selection" }
+        let titles = windows.prefix(maxItems).map { item in
+            item.app == item.displayTitle ? item.app : "\(item.app): \(item.displayTitle)"
+        }
+        if windows.count > maxItems {
+            return titles.joined(separator: " • ") + " +\(windows.count - maxItems)"
+        }
+        return titles.joined(separator: " • ")
+    }
+}