@lattices/cli 0.4.5 → 0.4.7

package/app/Sources/Core/Overlays/OverlayPanelShell.swift

@@ -0,0 +1,241 @@
+import AppKit
+import SwiftUI
+
+final class OverlayPanel: NSPanel {
+    var activatesOnMouseDown = false
+    var onKeyDown: ((NSEvent) -> Void)?
+    var onFlagsChanged: ((NSEvent) -> Void)?
+
+    override var canBecomeKey: Bool { true }
+    override var canBecomeMain: Bool { true }
+
+    override func sendEvent(_ event: NSEvent) {
+        if activatesOnMouseDown,
+           event.type == .leftMouseDown || event.type == .rightMouseDown {
+            if !NSApp.isActive {
+                NSApp.activate(ignoringOtherApps: true)
+            }
+            if !isKeyWindow {
+                makeKey()
+            }
+        }
+        super.sendEvent(event)
+    }
+
+    override func keyDown(with event: NSEvent) {
+        if let onKeyDown {
+            onKeyDown(event)
+        } else {
+            super.keyDown(with: event)
+        }
+    }
+
+    override func flagsChanged(with event: NSEvent) {
+        if let onFlagsChanged {
+            onFlagsChanged(event)
+        } else {
+            super.flagsChanged(with: event)
+        }
+    }
+}
+
+private final class OverlayHostingView<Content: View>: NSHostingView<Content> {
+    override func acceptsFirstMouse(for event: NSEvent?) -> Bool { true }
+    override var focusRingType: NSFocusRingType { get { .none } set {} }
+}
+
+struct OverlayPanelShell {
+    enum Background {
+        case clear
+        case solid(NSColor)
+        case material(NSVisualEffectView.Material)
+    }
+
+    enum Placement {
+        case centered(yOffsetRatio: CGFloat = 0)
+        case mouseScreenCentered(yOffsetRatio: CGFloat = 0)
+        case topCenter(margin: CGFloat = 40)
+    }
+
+    struct Config {
+        var size: NSSize
+        var styleMask: NSWindow.StyleMask = [.nonactivatingPanel]
+        var title: String = ""
+        var titleVisible: NSWindow.TitleVisibility = .hidden
+        var titlebarAppearsTransparent = false
+        var background: Background = .clear
+        var cornerRadius: CGFloat? = nil
+        var level: NSWindow.Level = .floating
+        var hasShadow = true
+        var hidesOnDeactivate = false
+        var isReleasedWhenClosed = false
+        var isMovableByWindowBackground = false
+        var collectionBehavior: NSWindow.CollectionBehavior = [.canJoinAllSpaces, .fullScreenAuxiliary]
+        var minSize: NSSize? = nil
+        var maxSize: NSSize? = nil
+        var activatesOnMouseDown = false
+        var onKeyDown: ((NSEvent) -> Void)? = nil
+        var onFlagsChanged: ((NSEvent) -> Void)? = nil
+        var appearance: NSAppearance? = NSAppearance(named: .darkAqua)
+    }
+
+    static func makePanel<Content: View>(config: Config, rootView: Content) -> OverlayPanel {
+        let hosting = OverlayHostingView(rootView: rootView)
+        hosting.translatesAutoresizingMaskIntoConstraints = false
+
+        let panel = OverlayPanel(
+            contentRect: NSRect(origin: .zero, size: config.size),
+            styleMask: config.styleMask,
+            backing: .buffered,
+            defer: false
+        )
+        panel.title = config.title
+        panel.titleVisibility = config.titleVisible
+        panel.titlebarAppearsTransparent = config.titlebarAppearsTransparent
+        panel.isOpaque = false
+        panel.backgroundColor = backgroundColor(for: config.background)
+        panel.level = config.level
+        panel.hasShadow = config.hasShadow
+        panel.hidesOnDeactivate = config.hidesOnDeactivate
+        panel.isReleasedWhenClosed = config.isReleasedWhenClosed
+        panel.isMovableByWindowBackground = config.isMovableByWindowBackground
+        panel.collectionBehavior = config.collectionBehavior
+        panel.activatesOnMouseDown = config.activatesOnMouseDown
+        panel.onKeyDown = config.onKeyDown
+        panel.onFlagsChanged = config.onFlagsChanged
+        if let minSize = config.minSize {
+            panel.minSize = minSize
+        }
+        if let maxSize = config.maxSize {
+            panel.maxSize = maxSize
+        }
+        if let appearance = config.appearance {
+            panel.appearance = appearance
+        }
+
+        install(hosting: hosting, on: panel, background: config.background, cornerRadius: config.cornerRadius)
+        return panel
+    }
+
+    static func position(_ window: NSWindow, placement: Placement) {
+        let screen: NSScreen
+        switch placement {
+        case .mouseScreenCentered, .topCenter:
+            screen = mouseScreen()
+        case .centered:
+            screen = NSScreen.main ?? mouseScreen()
+        }
+
+        let visibleFrame = screen.visibleFrame
+        let size = window.frame.size
+        let origin: NSPoint
+
+        switch placement {
+        case .centered(let yOffsetRatio), .mouseScreenCentered(let yOffsetRatio):
+            origin = NSPoint(
+                x: visibleFrame.midX - size.width / 2,
+                y: visibleFrame.midY - size.height / 2 + (visibleFrame.height * yOffsetRatio)
+            )
+        case .topCenter(let margin):
+            origin = NSPoint(
+                x: visibleFrame.midX - size.width / 2,
+                y: visibleFrame.maxY - size.height - margin
+            )
+        }
+
+        window.setFrameOrigin(origin)
+    }
+
+    static func present(
+        _ panel: NSPanel,
+        activate: Bool = true,
+        makeKey: Bool = true,
+        orderFrontRegardless: Bool = false
+    ) {
+        if orderFrontRegardless {
+            panel.orderFrontRegardless()
+        } else if makeKey {
+            panel.makeKeyAndOrderFront(nil)
+        } else {
+            panel.orderFront(nil)
+        }
+
+        if makeKey {
+            panel.makeKey()
+        }
+
+        if activate {
+            NSApp.activate(ignoringOtherApps: true)
+        }
+    }
+
+    private static func install(
+        hosting: NSView,
+        on panel: NSPanel,
+        background: Background,
+        cornerRadius: CGFloat?
+    ) {
+        switch background {
+        case .material(let material):
+            let effectView = NSVisualEffectView()
+            effectView.blendingMode = .behindWindow
+            effectView.material = material
+            effectView.state = .active
+            effectView.wantsLayer = true
+            if let cornerRadius {
+                effectView.maskImage = maskImage(cornerRadius: cornerRadius)
+            }
+            panel.contentView = effectView
+            pin(hosting: hosting, to: effectView)
+        case .clear, .solid:
+            panel.contentView = hosting
+        }
+    }
+
+    private static func pin(hosting: NSView, to container: NSView) {
+        container.addSubview(hosting)
+        NSLayoutConstraint.activate([
+            hosting.leadingAnchor.constraint(equalTo: container.leadingAnchor),
+            hosting.trailingAnchor.constraint(equalTo: container.trailingAnchor),
+            hosting.topAnchor.constraint(equalTo: container.topAnchor),
+            hosting.bottomAnchor.constraint(equalTo: container.bottomAnchor),
+        ])
+    }
+
+    private static func mouseScreen() -> NSScreen {
+        let mouseLocation = NSEvent.mouseLocation
+        return NSScreen.screens.first(where: { $0.frame.contains(mouseLocation) })
+            ?? NSScreen.main
+            ?? NSScreen.screens.first!
+    }
+
+    private static func backgroundColor(for background: Background) -> NSColor {
+        switch background {
+        case .clear, .material:
+            return .clear
+        case .solid(let color):
+            return color
+        }
+    }
+
+    private static func maskImage(cornerRadius: CGFloat) -> NSImage {
+        let edgeLength = 2.0 * cornerRadius + 1.0
+        let maskImage = NSImage(
+            size: NSSize(width: edgeLength, height: edgeLength),
+            flipped: false
+        ) { rect in
+            let path = NSBezierPath(roundedRect: rect, xRadius: cornerRadius, yRadius: cornerRadius)
+            NSColor.black.set()
+            path.fill()
+            return true
+        }
+        maskImage.capInsets = NSEdgeInsets(
+            top: cornerRadius,
+            left: cornerRadius,
+            bottom: cornerRadius,
+            right: cornerRadius
+        )
+        maskImage.resizingMode = .stretch
+        return maskImage
+    }
+}

package/app/Sources/{ScreenMapState.swift → Core/Overlays/ScreenMap/ScreenMapState.swift}

@@ -1388,7 +1388,9 @@ final class ScreenMapController: ObservableObject {
     @Published var editor: ScreenMapEditorState? {
         didSet { bindEditor() }
     }
-    @Published var selectedWindowIds: Set<UInt32> = []
+    @Published var selectedWindowIds: Set<UInt32> = [] {
+        didSet { syncSharedSelection() }
+    }
     @Published var windowSets: [ScreenMapWindowSet] = []
     @Published var activeWindowSetID: UUID? = nil
     @Published var flashMessage: String? = nil
@@ -1484,6 +1486,28 @@ final class ScreenMapController: ObservableObject {
         activeWindowSetID = nil
     }
 
+    private func syncSharedSelection() {
+        guard !selectedWindowIds.isEmpty else {
+            WindowSelectionStore.shared.clear(source: "screen-map")
+            return
+        }
+
+        guard let editor else { return }
+        let summaries = editor.windows
+            .filter { selectedWindowIds.contains($0.id) }
+            .map {
+                SelectedWindowSummary(
+                    wid: $0.id,
+                    app: $0.app,
+                    title: $0.title,
+                    latticesSession: $0.latticesSession
+                )
+            }
+
+        guard !summaries.isEmpty else { return }
+        WindowSelectionStore.shared.setSelection(summaries, source: "screen-map")
+    }
+
     func selectNextWindow() {
         guard let ed = editor else { return }
         let wins = ed.focusedVisibleWindows.sorted(by: { $0.zIndex < $1.zIndex })
@@ -2011,7 +2035,6 @@ final class ScreenMapController: ObservableObject {
 
     func handleKey(_ keyCode: UInt16, modifiers: NSEvent.ModifierFlags = []) -> Bool {
         let diag = DiagnosticLog.shared
-        diag.info("[ScreenMap] key: \(keyCode)")
 
         // Tiling mode intercepts keys before anything else
         if editor?.isTilingMode == true {

package/app/Sources/{ScreenMapView.swift → Core/Overlays/ScreenMap/ScreenMapView.swift}

@@ -1805,6 +1805,7 @@ struct ScreenMapView: View {
         let displays = editor?.displays ?? []
         let zoomLevel = editor?.zoomLevel ?? 1.0
         let panOffset = editor?.panOffset ?? .zero
+        let canvasShape = RoundedRectangle(cornerRadius: 6, style: .continuous)
 
         return GeometryReader { geo in
             let metrics = CanvasMetrics(editor: editor, displays: displays, viewportSize: geo.size)
@@ -1852,12 +1853,14 @@ struct ScreenMapView: View {
         }
         .padding(8)
         .frame(maxWidth: .infinity, maxHeight: .infinity)
+        .contentShape(canvasShape)
+        .clipShape(canvasShape)
         .clipped()
         .background(
             ZStack {
-                RoundedRectangle(cornerRadius: 6)
+                canvasShape
                     .fill(Color.black.opacity(0.25))
-                RoundedRectangle(cornerRadius: 6)
+                canvasShape
                     .strokeBorder(Color.white.opacity(0.06), lineWidth: 0.5)
                 Canvas { context, size in
                     let spacing: CGFloat = 20
@@ -2742,11 +2745,14 @@ struct ScreenMapView: View {
             }
             // Track space key for canvas drag-to-pan
             if event.keyCode == 49 && !controller.isSearchActive {
-                if event.type == .keyDown && !event.isARepeat {
-                    isSpaceHeld = true
-                    NSCursor.openHand.push()
+                if event.type == .keyDown {
+                    if !isSpaceHeld {
+                        isSpaceHeld = true
+                        NSCursor.openHand.push()
+                    }
                     return nil
                 } else if event.type == .keyUp {
+                    guard isSpaceHeld else { return nil }
                     isSpaceHeld = false
                     spaceDragStart = nil
                     NSCursor.pop()
@@ -2788,16 +2794,18 @@ struct ScreenMapView: View {
         mouseDownMonitor = NSEvent.addLocalMonitorForEvents(matching: .leftMouseDown) { event in
             guard let eventWindow = event.window,
                   eventWindow === ScreenMapWindowController.shared.nsWindow else { return event }
+            let flippedPt = flippedScreenPoint(event)
 
             // Space+click → begin canvas pan
-            if isSpaceHeld, let editor = controller.editor {
+            if isSpaceHeld,
+               isCanvasPoint(flippedPt),
+               let editor = controller.editor {
                 spaceDragStart = event.locationInWindow
                 spaceDragPanStart = editor.panOffset
                 NSCursor.closedHand.push()
                 return nil
             }
 
-            let flippedPt = flippedScreenPoint(event)
             if let editor = controller.editor,
                let hit = canvasHit(flippedScreenPt: flippedPt, editor: editor),
                hoveredWindowId == hit.id {
@@ -3042,6 +3050,7 @@ struct ScreenMapView: View {
     // MARK: - Hit Test / Coordinate Conversion
 
     private func canvasHit(flippedScreenPt: CGPoint, editor: ScreenMapEditorState) -> CanvasHit? {
+        guard isCanvasPoint(flippedScreenPt) else { return nil }
         let projection = CanvasProjection(editor: editor)
         guard projection.scale > 0 else { return nil }
         let canvasLocal = CGPoint(
@@ -3059,6 +3068,10 @@ struct ScreenMapView: View {
         return nil
     }
 
+    private func isCanvasPoint(_ point: CGPoint) -> Bool {
+        CGRect(origin: screenMapCanvasOrigin, size: screenMapCanvasSize).contains(point)
+    }
+
     private func detectDragMode(mapPoint: CGPoint, windowMapRect: CGRect) -> CanvasDragMode {
         let w = windowMapRect.width
         let h = windowMapRect.height

package/app/Sources/{VoiceCommandWindow.swift → Core/Overlays/Voice/VoiceCommandWindow.swift}

@@ -2,55 +2,12 @@ import AppKit
 import Combine
 import SwiftUI
 
-// MARK: - Panel subclass (handles keyDown when focused)
-
-final class VoicePanel: NSPanel {
-    var onKeyDown: ((NSEvent) -> Void)?
-    var onFlagsChanged: ((NSEvent) -> Void)?
-
-    override var canBecomeKey: Bool { true }
-    override var canBecomeMain: Bool { true }
-
-    override func sendEvent(_ event: NSEvent) {
-        if event.type == .leftMouseDown || event.type == .rightMouseDown {
-            if !NSApp.isActive {
-                NSApp.activate(ignoringOtherApps: true)
-            }
-            if !isKeyWindow {
-                makeKey()
-            }
-        }
-        super.sendEvent(event)
-    }
-
-    override func keyDown(with event: NSEvent) {
-        if let handler = onKeyDown {
-            handler(event)
-        } else {
-            super.keyDown(with: event)
-        }
-    }
-
-    override func flagsChanged(with event: NSEvent) {
-        if let handler = onFlagsChanged {
-            handler(event)
-        } else {
-            super.flagsChanged(with: event)
-        }
-    }
-}
-
-private final class VoiceHostingView<Content: View>: NSHostingView<Content> {
-    override func acceptsFirstMouse(for event: NSEvent?) -> Bool { true }
-    override var focusRingType: NSFocusRingType { get { .none } set {} }
-}
-
 // MARK: - Window Controller
 
 final class VoiceCommandWindow {
     static let shared = VoiceCommandWindow()
 
-    private(set) var panel: VoicePanel?
+    private(set) var panel: OverlayPanel?
     private var keyMonitor: Any?
     private var state: VoiceCommandState?
 
@@ -66,7 +23,7 @@ final class VoiceCommandWindow {
 
     func show() {
         // If panel exists but is hidden, just re-show it
-        if let p = panel, let s = state {
+        if let p = panel, state != nil {
             p.alphaValue = 0
             p.orderFrontRegardless()
             NSAnimationContext.runAnimationGroup { ctx in
@@ -87,42 +44,32 @@ final class VoiceCommandWindow {
         .preferredColorScheme(.dark)
 
         let mouseLocation = NSEvent.mouseLocation
-        let screen = NSScreen.screens.first(where: { $0.frame.contains(mouseLocation) }) ?? NSScreen.main ?? NSScreen.screens.first!
+        let screen = NSScreen.screens.first(where: { $0.frame.contains(mouseLocation) })
+            ?? NSScreen.main
+            ?? NSScreen.screens.first!
         let visible = screen.visibleFrame
-
         let panelWidth: CGFloat = min(900, visible.width - 80)
         let panelHeight: CGFloat = min(560, visible.height - 80)
 
-        let p = VoicePanel(
-            contentRect: NSRect(x: 0, y: 0, width: panelWidth, height: panelHeight),
-            styleMask: [.titled, .nonactivatingPanel],
-            backing: .buffered,
-            defer: false
+        let p = OverlayPanelShell.makePanel(
+            config: .init(
+                size: NSSize(width: panelWidth, height: panelHeight),
+                styleMask: [.titled, .nonactivatingPanel],
+                titleVisible: .hidden,
+                titlebarAppearsTransparent: true,
+                background: .clear,
+                hidesOnDeactivate: false,
+                isMovableByWindowBackground: true,
+                activatesOnMouseDown: true,
+                onKeyDown: { [weak self] event in self?.handleKey(event) },
+                onFlagsChanged: { [weak self] event in self?.handleFlags(event) }
+            ),
+            rootView: view
         )
-        p.onKeyDown = { [weak self] event in self?.handleKey(event) }
-        p.onFlagsChanged = { [weak self] event in self?.handleFlags(event) }
-        p.titlebarAppearsTransparent = true
-        p.titleVisibility = .hidden
-        p.isOpaque = false
-        p.backgroundColor = .clear
-        p.level = .floating
-        p.hasShadow = true
-        p.hidesOnDeactivate = false
-        p.isReleasedWhenClosed = false
-        p.isMovableByWindowBackground = true
-        let hosting = VoiceHostingView(rootView: view)
-        hosting.translatesAutoresizingMaskIntoConstraints = false
-        p.contentView = hosting
-
-        // Position: top-center of screen
-        let x = visible.midX - panelWidth / 2
-        let y = visible.maxY - panelHeight - 40
-        p.setFrameOrigin(NSPoint(x: x, y: y))
+        OverlayPanelShell.position(p, placement: .topCenter(margin: 40))
 
         p.alphaValue = 0
-        p.orderFrontRegardless()
-        p.makeKey()
-        NSApp.activate(ignoringOtherApps: true)
+        OverlayPanelShell.present(p, activate: true, makeKey: true, orderFrontRegardless: true)
 
         NSAnimationContext.runAnimationGroup { ctx in
             ctx.duration = 0.15
@@ -560,6 +507,7 @@ final class VoiceCommandState: ObservableObject {
 
 struct VoiceCommandView: View {
     @ObservedObject var state: VoiceCommandState
+    @ObservedObject private var activeSelection = WindowSelectionStore.shared
     let onDismiss: () -> Void
 
     private let docsURL = "https://lattices.dev/docs/voice"
@@ -884,6 +832,30 @@ struct VoiceCommandView: View {
             VStack(alignment: .leading, spacing: 14) {
                     // Zero-height spacer forces VStack to fill ScrollView width
                     Color.clear.frame(maxWidth: .infinity, maxHeight: 0)
+                    if activeSelection.isActive {
+                        commandSection("selection") {
+                            VStack(alignment: .leading, spacing: 6) {
+                                HStack(spacing: 6) {
+                                    Text("\(activeSelection.count) window\(activeSelection.count == 1 ? "" : "s")")
+                                        .font(Typo.geistMonoBold(11))
+                                        .foregroundColor(Palette.running)
+                                    if let source = activeSelection.sourceLabel {
+                                        Text(source)
+                                            .font(Typo.geistMono(10))
+                                            .foregroundColor(Palette.textMuted)
+                                    }
+                                }
+                                Text(activeSelection.summary(maxItems: 4))
+                                    .font(Typo.geistMono(11))
+                                    .foregroundColor(Palette.textDim)
+                                    .lineLimit(3)
+                                Text("Try: grid that in the bottom half")
+                                    .font(Typo.geistMono(10))
+                                    .foregroundColor(Palette.textMuted)
+                            }
+                        }
+                    }
+
                     // Partial transcript (while listening)
                     if state.phase == .listening, !state.partialText.isEmpty {
                         commandSection("hearing...") {

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

@@ -66,12 +66,40 @@ struct GridFile: Codable {
     let snapZones: SnapZonesConfig?
 }
 
-enum SnapModifierKey: String, Codable, Equatable {
+enum SnapModifierKey: String, Codable, Equatable, CaseIterable, Identifiable {
     case command
     case option
     case control
     case shift
 
+    var id: String { rawValue }
+
+    var label: String {
+        switch self {
+        case .command:
+            return "Command"
+        case .option:
+            return "Option"
+        case .control:
+            return "Control"
+        case .shift:
+            return "Shift"
+        }
+    }
+
+    var shortLabel: String {
+        switch self {
+        case .command:
+            return "Cmd"
+        case .option:
+            return "Opt"
+        case .control:
+            return "Ctrl"
+        case .shift:
+            return "Shift"
+        }
+    }
+
     var eventFlags: NSEvent.ModifierFlags {
         switch self {
         case .command:
@@ -98,9 +126,6 @@ enum SnapModifierKey: String, Codable, Equatable {
         }
     }
 
-    var label: String {
-        rawValue.capitalized
-    }
 }
 
 enum SnapZoneTriggerSpec: Codable, Equatable {
@@ -459,6 +484,36 @@ class WorkspaceManager: ObservableObject {
         self.snapZonesConfig = snapZones
     }
 
+    func updateSnapModifier(_ modifier: SnapModifierKey) {
+        let updated = SnapZonesConfig(
+            enabled: snapZonesConfig.enabled,
+            modifier: modifier,
+            zoneOpacity: snapZonesConfig.zoneOpacity,
+            highlightOpacity: snapZonesConfig.highlightOpacity,
+            previewOpacity: snapZonesConfig.previewOpacity,
+            cornerRadius: snapZonesConfig.cornerRadius,
+            rules: snapZonesConfig.rules
+        )
+
+        do {
+            let url = URL(fileURLWithPath: snapZonesConfigPath)
+            try FileManager.default.createDirectory(
+                at: url.deletingLastPathComponent(),
+                withIntermediateDirectories: true
+            )
+
+            let encoder = JSONEncoder()
+            encoder.outputFormatting = [.prettyPrinted, .sortedKeys]
+            let data = try encoder.encode(updated)
+            try data.write(to: url, options: .atomic)
+
+            loadGridConfig()
+            DiagnosticLog.shared.info("WorkspaceManager: updated snap modifier to \(modifier.rawValue)")
+        } catch {
+            DiagnosticLog.shared.error("WorkspaceManager: failed to write snap-zones.json — \(error.localizedDescription)")
+        }
+    }
+
     /// Resolve a tile string to fractions: check user presets first, then built-in TilePosition
     func resolveTileFractions(_ tile: String) -> (CGFloat, CGFloat, CGFloat, CGFloat)? {
         resolvePlacement(tile)?.fractions