@lattices/cli 0.4.5 → 0.4.7

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

@@ -45,6 +45,11 @@ enum DesktopInventoryMode: Equatable {
     case screenMap    // m → interactive screen map editor
 }
 
+enum CommandModeLaunchMode: Equatable {
+    case normal
+    case organize(appName: String?)
+}
+
 // DisplayGeometry, ScreenMapWindowEntry, ScreenMapEditorState, ScreenMapActionLog
 // are defined in ScreenMapState.swift
 // MARK: - Filter Presets
@@ -91,11 +96,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
@@ -129,10 +137,43 @@ final class CommandModeState: ObservableObject {
 
     var onDismiss: (() -> Void)?
     var onPanelResize: ((_ width: CGFloat, _ height: CGFloat) -> Void)?
+    private let launchMode: CommandModeLaunchMode
 
     /// Tracks the last item navigated to, for consistent Shift+arrow multi-select
     private var cursorWindowId: UInt32?
 
+    init(launchMode: CommandModeLaunchMode = .normal) {
+        self.launchMode = launchMode
+    }
+
+    var isOrganizeFlow: Bool {
+        if case .organize = launchMode { return true }
+        return false
+    }
+
+    var organizeSeedAppName: String? {
+        if case .organize(let appName) = launchMode { return appName }
+        return nil
+    }
+
+    var organizeSelectionSummary: String {
+        let count = selectedWindowIds.count
+        if let appName = organizeSeedAppName, !appName.isEmpty {
+            return "\(count) \(appName) window\(count == 1 ? "" : "s") selected"
+        }
+        return "\(count) window\(count == 1 ? "" : "s") selected"
+    }
+
+    var organizeGuidance: String {
+        if selectedWindowIds.count > 1 {
+            return "Press D to organize. Cmd-click adds or removes windows. Shift-click extends the selection."
+        }
+        if selectedWindowIds.count == 1 {
+            return "Cmd-click another window to add it, then press D to organize the set."
+        }
+        return "Click windows to select them. Cmd-click adds or removes windows, and D organizes the selection."
+    }
+
     // MARK: - Selection Helpers
 
     /// Backwards-compat: returns single selected ID (first element)
@@ -140,6 +181,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,7 +405,9 @@ final class CommandModeState: ObservableObject {
         desktopSnapshot = buildDesktopInventory()
         clearSelection()
         desktopMode = .browsing
+        gridPreviewPlacement = nil
         phase = .desktopInventory
+        configureLaunchMode()
         // Don't call onPanelResize here — caller handles initial sizing
     }
 
@@ -535,6 +598,7 @@ final class CommandModeState: ObservableObject {
             if isSearching && selectedWindowIds.isEmpty { return false }
             if isSearching { deactivateSearch() }
             if !selectedWindowIds.isEmpty {
+                gridPreviewPlacement = nil
                 desktopMode = .gridPreview
             }
             return true
@@ -551,6 +615,20 @@ final class CommandModeState: ObservableObject {
             }
             return true
 
+        case 2: // d → distribute selected
+            if isSearching && selectedWindowIds.isEmpty { return false }
+            if isSearching { deactivateSearch() }
+            guard !selectedWindowIds.isEmpty else {
+                flash("Select 2+ windows to organize")
+                return true
+            }
+            guard selectedWindowIds.count > 1 else {
+                flash("Add another window, then press D to organize")
+                return true
+            }
+            distributeSelected()
+            return true
+
         case 46: // m → screen map editor (standalone window)
             if isSearching { deactivateSearch() }
             ScreenMapWindowController.shared.show()
@@ -614,15 +692,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 +912,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 +954,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 +1073,84 @@ 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
+        }
+    }
+
+    private func configureLaunchMode() {
+        switch launchMode {
+        case .normal:
+            return
+        case .organize(let appName):
+            activePreset = .currentSpace
+            seedSelectionForOrganization(appName: appName)
+        }
+    }
+
+    private func seedSelectionForOrganization(appName: String?) {
+        let visibleWindows = flatWindowList.filter(\.isOnScreen)
+        let targetApp = appName ?? visibleWindows.first?.appName
+        let initialSelection = visibleWindows.filter { window in
+            guard let name = window.appName, let targetApp else { return false }
+            return name.localizedCaseInsensitiveCompare(targetApp) == .orderedSame
+        }
+
+        if initialSelection.isEmpty {
+            flash("Select windows to organize. Cmd-click adds or removes windows; D distributes.")
+            return
+        }
+
+        selectedWindowIds = Set(initialSelection.map(\.id))
+        cursorWindowId = initialSelection.first?.id
+
+        if let targetApp {
+            if initialSelection.count > 1 {
+                flash("Selected \(initialSelection.count) \(targetApp) windows. Press D to organize.")
+            } else {
+                flash("Selected the \(targetApp) window. Cmd-click more windows, then press D.")
+            }
+        } else if initialSelection.count > 1 {
+            flash("Selected \(initialSelection.count) windows. Press D to organize.")
+        } else {
+            flash("Selected 1 window. Cmd-click more windows, then press D.")
+        }
+
+        DispatchQueue.main.async { [weak self] in
+            guard let self = self else { return }
+            if self.selectedWindowIds.count > 1 {
+                self.highlightAllSelected()
+            } else {
+                self.highlightSelectedWindow()
+            }
+        }
+    }
+
     // MARK: - Inventory Builder
 
     private func buildInventory() -> CommandModeInventory {
@@ -1360,3 +1551,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
+    }
+}