@lattices/cli 0.4.5 → 0.4.6

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: " • ")
+    }
+}

package/app/Sources/{WindowTiler.swift → Core/Desktop/WindowTiler.swift}

@@ -671,18 +671,7 @@ enum WindowTiler {
 
     /// Find a window by its title tag and return its CGWindowID and owner PID
     static func findWindow(tag: String) -> (wid: UInt32, pid: pid_t)? {
-        guard let windowList = CGWindowListCopyWindowInfo([.optionAll, .excludeDesktopElements], kCGNullWindowID) as? [[String: Any]] else {
-            return nil
-        }
-        for info in windowList {
-            if let name = info[kCGWindowName as String] as? String,
-               name.contains(tag),
-               let wid = info[kCGWindowNumber as String] as? UInt32,
-               let pid = info[kCGWindowOwnerPID as String] as? pid_t {
-                return (wid, pid)
-            }
-        }
-        return nil
+        SessionWindowLocator.findCGWindow(tag: tag).map { ($0.wid, $0.pid) }
     }
 
     /// Get the space ID(s) a window is on
@@ -760,13 +749,9 @@ enum WindowTiler {
 
         // Find the window — CG first, then AX→CG fallback
         let wid: UInt32
-        if let (w, _) = findWindow(tag: tag) {
-            wid = w
-            diag.info("moveWindowToSpace: found via CG wid=\(w)")
-        } else if let (pid, axWindow) = findWindowViaAX(terminal: terminal, tag: tag),
-                  let w = matchCGWindow(pid: pid, axWindow: axWindow) {
-            wid = w
-            diag.info("moveWindowToSpace: found via AX→CG wid=\(w)")
+        if let match = SessionWindowLocator.findWindow(tag: tag, terminal: terminal) {
+            wid = match.wid
+            diag.info("moveWindowToSpace: located wid=\(match.wid) pid=\(match.pid)")
         } else {
             diag.warn("moveWindowToSpace: window not found for tag \(tag) — switching view only")
             switchToSpace(spaceId: spaceId)
@@ -834,39 +819,31 @@ enum WindowTiler {
         let tag = Terminal.windowTag(for: session)
 
         // Path 1: CG window lookup (needs Screen Recording permission for window names)
-        if let (wid, pid) = findWindow(tag: tag) {
-            diag.success("Path 1 (CG): found wid=\(wid) pid=\(pid)")
-            navigateToKnownWindow(wid: wid, pid: pid, tag: tag, session: session, terminal: terminal)
+        if let match = SessionWindowLocator.findWindow(tag: tag, terminal: terminal) {
+            diag.success("Path 1/2 (locator): found wid=\(match.wid) pid=\(match.pid)")
+            navigateToKnownWindow(wid: match.wid, pid: match.pid, tag: tag, session: session, terminal: terminal)
             diag.finish(t)
             return
         }
-        diag.warn("Path 1 (CG): findWindow failed — no Screen Recording?")
+        diag.warn("SessionWindowLocator failed — trying direct AX fallback")
 
-        // Path 2: AX API fallback (needs Accessibility permission)
-        if let (pid, axWindow) = findWindowViaAX(terminal: terminal, tag: tag) {
-            diag.success("Path 2 (AX): found window for \(terminal.rawValue) pid=\(pid)")
-            // Try to match AX window → CG window for space switching
-            if let wid = matchCGWindow(pid: pid, axWindow: axWindow) {
-                diag.success("Path 2 (AX→CG): matched CG wid=\(wid)")
-                navigateToKnownWindow(wid: wid, pid: pid, tag: tag, session: session, terminal: terminal)
+        if let (pid, axWindow) = SessionWindowLocator.findAXWindow(terminal: terminal, tag: tag) {
+            diag.success("Direct AX fallback: found window for \(terminal.rawValue) pid=\(pid)")
+            AXUIElementPerformAction(axWindow, kAXRaiseAction as CFString)
+            AXUIElementSetAttributeValue(axWindow, kAXMainAttribute as CFString, kCFBooleanTrue)
+            if let app = NSRunningApplication(processIdentifier: pid) {
+                app.activate()
+            }
+            if let frame = axWindowFrame(axWindow) {
+                diag.info("Highlighting via AX frame: \(frame)")
+                DispatchQueue.main.async { WindowHighlight.shared.flash(frame: frame) }
             } else {
-                diag.warn("Path 2 (AX): no CG match — raising without space switch")
-                AXUIElementPerformAction(axWindow, kAXRaiseAction as CFString)
-                AXUIElementSetAttributeValue(axWindow, kAXMainAttribute as CFString, kCFBooleanTrue)
-                if let app = NSRunningApplication(processIdentifier: pid) {
-                    app.activate()
-                }
-                if let frame = axWindowFrame(axWindow) {
-                    diag.info("Highlighting via AX frame: \(frame)")
-                    DispatchQueue.main.async { WindowHighlight.shared.flash(frame: frame) }
-                } else {
-                    diag.error("axWindowFrame returned nil — no highlight")
-                }
+                diag.error("axWindowFrame returned nil — no highlight")
             }
             diag.finish(t)
             return
         }
-        diag.warn("Path 2 (AX): findWindowViaAX failed — no Accessibility?")
+        diag.warn("Direct AX fallback failed — no Accessibility?")
 
         // Path 3: AppleScript / bare activate fallback
         diag.warn("Path 3: falling back to AppleScript/activate")
@@ -894,70 +871,12 @@ enum WindowTiler {
         }
     }
 
-    /// Find a terminal window by title tag using AX API (requires Accessibility permission)
     private static func findWindowViaAX(terminal: Terminal, tag: String) -> (pid: pid_t, window: AXUIElement)? {
-        let diag = DiagnosticLog.shared
-        guard let app = NSWorkspace.shared.runningApplications.first(where: {
-            $0.bundleIdentifier == terminal.bundleId
-        }) else {
-            diag.error("findWindowViaAX: \(terminal.rawValue) (\(terminal.bundleId)) not running")
-            return nil
-        }
-
-        let pid = app.processIdentifier
-        let appRef = AXUIElementCreateApplication(pid)
-        var windowsRef: CFTypeRef?
-        let err = AXUIElementCopyAttributeValue(appRef, kAXWindowsAttribute as CFString, &windowsRef)
-        guard err == .success, let windows = windowsRef as? [AXUIElement] else {
-            diag.error("findWindowViaAX: AX error \(err.rawValue) — Accessibility not granted?")
-            return nil
-        }
-
-        diag.info("findWindowViaAX: \(windows.count) windows for \(terminal.rawValue), searching for \(tag)")
-        for win in windows {
-            var titleRef: CFTypeRef?
-            AXUIElementCopyAttributeValue(win, kAXTitleAttribute as CFString, &titleRef)
-            let title = titleRef as? String ?? "<no title>"
-            if title.contains(tag) {
-                diag.success("findWindowViaAX: matched \"\(title)\"")
-                return (pid, win)
-            } else {
-                diag.info("  skip: \"\(title)\"")
-            }
-        }
-        diag.warn("findWindowViaAX: no window matched tag \(tag)")
-        return nil
+        SessionWindowLocator.findAXWindow(terminal: terminal, tag: tag)
     }
 
-    /// Match an AX window to its CG window ID using PID + bounds comparison
     private static func matchCGWindow(pid: pid_t, axWindow: AXUIElement) -> UInt32? {
-        var posRef: CFTypeRef?
-        var sizeRef: CFTypeRef?
-        AXUIElementCopyAttributeValue(axWindow, kAXPositionAttribute as CFString, &posRef)
-        AXUIElementCopyAttributeValue(axWindow, kAXSizeAttribute as CFString, &sizeRef)
-        guard let pv = posRef, let sv = sizeRef else { return nil }
-
-        var pos = CGPoint.zero
-        var size = CGSize.zero
-        AXValueGetValue(pv as! AXValue, .cgPoint, &pos)
-        AXValueGetValue(sv as! AXValue, .cgSize, &size)
-
-        guard let windowList = CGWindowListCopyWindowInfo([.optionAll, .excludeDesktopElements], kCGNullWindowID) as? [[String: Any]] else { return nil }
-
-        for info in windowList {
-            guard let wPid = info[kCGWindowOwnerPID as String] as? pid_t,
-                  wPid == pid,
-                  let wid = info[kCGWindowNumber as String] as? UInt32,
-                  let boundsDict = info[kCGWindowBounds as String] as? NSDictionary else { continue }
-            var rect = CGRect.zero
-            if CGRectMakeWithDictionaryRepresentation(boundsDict, &rect) {
-                if abs(rect.origin.x - pos.x) < 2 && abs(rect.origin.y - pos.y) < 2 &&
-                   abs(rect.width - size.width) < 2 && abs(rect.height - size.height) < 2 {
-                    return wid
-                }
-            }
-        }
-        return nil
+        SessionWindowLocator.matchCGWindow(pid: pid, axWindow: axWindow)
     }
 
     /// Get NSRect from an AX window element (AX uses top-left origin, convert to NS bottom-left)
@@ -1107,11 +1026,8 @@ enum WindowTiler {
 
         // Find the window
         let wid: UInt32
-        if let (w, _) = findWindow(tag: tag) {
-            wid = w
-        } else if let (pid, axWindow) = findWindowViaAX(terminal: terminal, tag: tag),
-                  let w = matchCGWindow(pid: pid, axWindow: axWindow) {
-            wid = w
+        if let match = SessionWindowLocator.findWindow(tag: tag, terminal: terminal) {
+            wid = match.wid
         } else {
             return nil
         }

package/app/Sources/{CommandModeState.swift → Core/Overlays/CommandMode/CommandModeState.swift}

@@ -91,11 +91,14 @@ final class CommandModeState: ObservableObject {
     @Published var inventory = CommandModeInventory(activeLayer: nil, layerCount: 0, items: [])
     @Published var chords: [Chord] = []
     @Published var desktopSnapshot: DesktopInventorySnapshot?
-    @Published var selectedWindowIds: Set<UInt32> = []
+    @Published var selectedWindowIds: Set<UInt32> = [] {
+        didSet { syncSharedSelection() }
+    }
     @Published var desktopMode: DesktopInventoryMode = .browsing
     @Published var activePreset: FilterPreset? = nil
     @Published var searchQuery: String = ""
     @Published var isSearching: Bool = false
+    @Published var gridPreviewPlacement: PlacementSpec? = nil
 
     // MARK: - Marquee Drag State
     @Published var isDragging: Bool = false
@@ -140,6 +143,26 @@ final class CommandModeState: ObservableObject {
         selectedWindowIds.first
     }
 
+    var selectedWindowSummaryText: String {
+        let windows = flatWindowList.filter { selectedWindowIds.contains($0.id) }
+        let labels = windows.compactMap { $0.appName }.uniquePrefix(3)
+        guard !labels.isEmpty else { return "" }
+        if windows.count > labels.count {
+            return labels.joined(separator: " • ") + " +\(windows.count - labels.count)"
+        }
+        return labels.joined(separator: " • ")
+    }
+
+    var gridPreviewRegionLabel: String {
+        guard let placement = gridPreviewPlacement else { return "Full Screen" }
+        switch placement {
+        case .tile(let position):
+            return position.label
+        default:
+            return placement.wireValue
+        }
+    }
+
     func isSelected(_ id: UInt32) -> Bool {
         selectedWindowIds.contains(id)
     }
@@ -344,6 +367,7 @@ final class CommandModeState: ObservableObject {
         desktopSnapshot = buildDesktopInventory()
         clearSelection()
         desktopMode = .browsing
+        gridPreviewPlacement = nil
         phase = .desktopInventory
         // Don't call onPanelResize here — caller handles initial sizing
     }
@@ -535,6 +559,7 @@ final class CommandModeState: ObservableObject {
             if isSearching && selectedWindowIds.isEmpty { return false }
             if isSearching { deactivateSearch() }
             if !selectedWindowIds.isEmpty {
+                gridPreviewPlacement = nil
                 desktopMode = .gridPreview
             }
             return true
@@ -614,15 +639,54 @@ final class CommandModeState: ObservableObject {
 
     private func handleGridPreviewKey(_ keyCode: UInt16) -> Bool {
         switch keyCode {
-        case 53: // Escape — always dismiss
-            onDismiss?()
+        case 53: // Escape — cancel preview, keep selection
+            gridPreviewPlacement = nil
+            desktopMode = .browsing
             return true
 
         case 36, 1: // Enter or s → apply the layout
-            showAndDistributeSelected()
+            showAndDistributeSelected(in: gridPreviewPlacement)
+            gridPreviewPlacement = nil
             desktopMode = .browsing
             return true
 
+        case 123:
+            gridPreviewPlacement = .tile(.left)
+            return true
+        case 124:
+            gridPreviewPlacement = .tile(.right)
+            return true
+        case 126:
+            gridPreviewPlacement = .tile(.top)
+            return true
+        case 125:
+            gridPreviewPlacement = .tile(.bottom)
+            return true
+        case 18:
+            gridPreviewPlacement = .tile(.topLeft)
+            return true
+        case 19:
+            gridPreviewPlacement = .tile(.topRight)
+            return true
+        case 20:
+            gridPreviewPlacement = .tile(.bottomLeft)
+            return true
+        case 21:
+            gridPreviewPlacement = .tile(.bottomRight)
+            return true
+        case 23:
+            gridPreviewPlacement = .tile(.leftThird)
+            return true
+        case 22:
+            gridPreviewPlacement = .tile(.centerThird)
+            return true
+        case 26:
+            gridPreviewPlacement = .tile(.rightThird)
+            return true
+        case 8:
+            gridPreviewPlacement = .tile(.center)
+            return true
+
         default:
             return true
         }
@@ -795,20 +859,8 @@ final class CommandModeState: ObservableObject {
     private func tileAllSelected(to position: TilePosition) {
         let windows = flatWindowList.filter { selectedWindowIds.contains($0.id) }
         guard !windows.isEmpty else { return }
-
-        // For left/right with 2+ windows: distribute evenly across width
-        if windows.count >= 2 && (position == .left || position == .right) {
-            distributeSelectedHorizontally()
-            return
-        }
-
-        DiagnosticLog.shared.info("Tile all \(windows.count): \(position.rawValue)")
-        for win in windows {
-            WindowTiler.tileWindowById(wid: win.id, pid: win.pid, to: position)
-        }
-        DispatchQueue.main.asyncAfter(deadline: .now() + 0.2) { [weak self] in
-            self?.desktopSnapshot = self?.buildDesktopInventory()
-        }
+        DiagnosticLog.shared.info("Grid selected \(windows.count): \(position.rawValue)")
+        showAndDistributeSelected(in: .tile(position))
     }
 
     private func distributeSelectedHorizontally() {
@@ -849,28 +901,36 @@ final class CommandModeState: ObservableObject {
     }
 
     /// Show all selected windows AND distribute in smart grid — single batch operation
-    func showAndDistributeSelected() {
+    func showAndDistributeSelected(in placement: PlacementSpec? = nil) {
         let windows = flatWindowList.filter { selectedWindowIds.contains($0.id) }
         guard !windows.isEmpty else { return }
         savePositions(for: windows)
-        WindowTiler.batchRaiseAndDistribute(windows: windows.map { (wid: $0.id, pid: $0.pid) })
+        WindowTiler.batchRaiseAndDistribute(
+            windows: windows.map { (wid: $0.id, pid: $0.pid) },
+            region: placement?.fractions
+        )
         let shape = WindowTiler.gridShape(for: windows.count)
         let grid = shape.map(String.init).joined(separator: "+")
-        flash("\(windows.count) windows [\(grid)]")
+        let region = placement.map { " in \(self.regionLabel(for: $0))" } ?? ""
+        flash("\(windows.count) windows\(region) [\(grid)]")
         DispatchQueue.main.asyncAfter(deadline: .now() + 0.2) { [weak self] in
             self?.desktopSnapshot = self?.buildDesktopInventory()
         }
     }
 
     /// Distribute selected in smart grid without raising
-    func distributeSelected() {
+    func distributeSelected(in placement: PlacementSpec? = nil) {
         let windows = flatWindowList.filter { selectedWindowIds.contains($0.id) }
         guard !windows.isEmpty else { return }
         savePositions(for: windows)
-        WindowTiler.batchRaiseAndDistribute(windows: windows.map { (wid: $0.id, pid: $0.pid) })
+        WindowTiler.batchRaiseAndDistribute(
+            windows: windows.map { (wid: $0.id, pid: $0.pid) },
+            region: placement?.fractions
+        )
         let shape = WindowTiler.gridShape(for: windows.count)
         let grid = shape.map(String.init).joined(separator: "+")
-        flash("\(windows.count) windows [\(grid)]")
+        let region = placement.map { " in \(self.regionLabel(for: $0))" } ?? ""
+        flash("\(windows.count) windows\(region) [\(grid)]")
         DispatchQueue.main.asyncAfter(deadline: .now() + 0.2) { [weak self] in
             self?.desktopSnapshot = self?.buildDesktopInventory()
         }
@@ -960,6 +1020,36 @@ final class CommandModeState: ObservableObject {
         onDismiss?()
     }
 
+    private func syncSharedSelection() {
+        guard !selectedWindowIds.isEmpty else {
+            WindowSelectionStore.shared.clear(source: "desktop-inventory")
+            return
+        }
+
+        let summaries = flatWindowList
+            .filter { selectedWindowIds.contains($0.id) }
+            .map {
+                SelectedWindowSummary(
+                    wid: $0.id,
+                    app: $0.appName ?? "Window",
+                    title: $0.title,
+                    latticesSession: $0.latticesSession
+                )
+            }
+
+        guard !summaries.isEmpty else { return }
+        WindowSelectionStore.shared.setSelection(summaries, source: "desktop-inventory")
+    }
+
+    private func regionLabel(for placement: PlacementSpec) -> String {
+        switch placement {
+        case .tile(let position):
+            return position.label
+        default:
+            return placement.wireValue
+        }
+    }
+
     // MARK: - Inventory Builder
 
     private func buildInventory() -> CommandModeInventory {
@@ -1360,3 +1450,16 @@ final class CommandModeState: ObservableObject {
         return chords
     }
 }
+
+private extension Sequence where Element == String {
+    func uniquePrefix(_ count: Int) -> [String] {
+        var seen = Set<String>()
+        var result: [String] = []
+        for item in self where !seen.contains(item) {
+            seen.insert(item)
+            result.append(item)
+            if result.count == count { break }
+        }
+        return result
+    }
+}