@lattices/cli 0.3.0

package/app/Sources/CommandModeWindow.swift

@@ -0,0 +1,192 @@
+import AppKit
+import SwiftUI
+
+/// NSPanel subclass that accepts key events and first-click mouse events.
+/// Overrides sendEvent to ensure the panel is key before processing clicks,
+/// which is required for SwiftUI gesture/button handling in .nonactivatingPanel panels.
+private class CommandModePanel: NSPanel {
+    override var canBecomeKey: Bool { true }
+    override var canBecomeMain: Bool { true }
+    override var acceptsMouseMovedEvents: Bool {
+        get { true }
+        set { super.acceptsMouseMovedEvents = newValue }
+    }
+
+    override func sendEvent(_ event: NSEvent) {
+        // Non-activating panels can silently lose key status. Re-assert key
+        // and app activation before every mouse-down so SwiftUI Buttons/gestures
+        // fire reliably — including the very first click after the panel appears.
+        if event.type == .leftMouseDown || event.type == .rightMouseDown {
+            if !NSApp.isActive {
+                NSApp.activate(ignoringOtherApps: true)
+            }
+            if !isKeyWindow { makeKey() }
+        }
+        super.sendEvent(event)
+    }
+}
+
+/// NSHostingView subclass that accepts first-click events in non-activating panels
+private class FirstClickHostingView<Content: View>: NSHostingView<Content> {
+    override func acceptsFirstMouse(for event: NSEvent?) -> Bool { true }
+    override var focusRingType: NSFocusRingType { get { .none } set {} }
+}
+
+final class CommandModeWindow {
+    static let shared = CommandModeWindow()
+
+    private var panel: NSPanel?
+    private var isOpen = false
+
+    /// Exposed for event monitor filtering (only handle clicks in this window)
+    var panelWindow: NSWindow? { panel }
+
+    var isVisible: Bool { isOpen }
+
+    func toggle() {
+        if isOpen {
+            dismiss()
+        } else {
+            show()
+        }
+    }
+
+    func show() {
+        // Always rebuild for fresh state
+        dismiss()
+        isOpen = true
+
+        // Dismiss palette if visible
+        if CommandPaletteWindow.shared.isVisible {
+            CommandPaletteWindow.shared.dismiss()
+        }
+
+        let state = CommandModeState()
+        state.onDismiss = { [weak self] in
+            self?.dismiss()
+        }
+        state.onPanelResize = { [weak self] width, height in
+            self?.animateResize(width: width, height: height)
+        }
+        state.enter()
+
+        // Compute initial size from state phase
+        let initialWidth: CGFloat
+        let initialHeight: CGFloat
+        if state.phase == .desktopInventory {
+            let displayCount = max(1, state.desktopSnapshot?.displays.count ?? 1)
+            let columnWidth: CGFloat = 480
+            initialWidth = CGFloat(displayCount) * columnWidth + CGFloat(displayCount - 1) + 32
+            initialHeight = 640
+        } else {
+            initialWidth = 580; initialHeight = 360
+        }
+
+        let view = CommandModeView(state: state)
+            .preferredColorScheme(.dark)
+
+        let hosting = FirstClickHostingView(rootView: view)
+        hosting.translatesAutoresizingMaskIntoConstraints = false
+
+        let panel = CommandModePanel(
+            contentRect: NSRect(x: 0, y: 0, width: initialWidth, height: initialHeight),
+            styleMask: [.nonactivatingPanel],
+            backing: .buffered,
+            defer: false
+        )
+
+        panel.isOpaque = false
+        panel.backgroundColor = .clear
+        panel.hasShadow = true
+        panel.level = .floating
+        panel.isMovableByWindowBackground = true
+        panel.hidesOnDeactivate = true
+        panel.becomesKeyOnlyIfNeeded = false
+        panel.collectionBehavior = [.canJoinAllSpaces, .fullScreenAuxiliary]
+        panel.isReleasedWhenClosed = false
+
+        let cornerRadius: CGFloat = 14
+
+        let effectView = NSVisualEffectView()
+        effectView.blendingMode = .behindWindow
+        effectView.material = .popover
+        effectView.state = .active
+        effectView.wantsLayer = true
+        effectView.maskImage = Self.maskImage(cornerRadius: cornerRadius)
+
+        panel.contentView = effectView
+
+        effectView.addSubview(hosting)
+        NSLayoutConstraint.activate([
+            hosting.leadingAnchor.constraint(equalTo: effectView.leadingAnchor),
+            hosting.trailingAnchor.constraint(equalTo: effectView.trailingAnchor),
+            hosting.topAnchor.constraint(equalTo: effectView.topAnchor),
+            hosting.bottomAnchor.constraint(equalTo: effectView.bottomAnchor),
+        ])
+
+        // Center horizontally, slightly above vertical center
+        if let screen = NSScreen.main {
+            let screenFrame = screen.visibleFrame
+            let clampedWidth = min(initialWidth, screenFrame.width * 0.92)
+            let clampedHeight = min(initialHeight, screenFrame.height * 0.85)
+            let x = screenFrame.midX - clampedWidth / 2
+            let y = screenFrame.midY - clampedHeight / 2 + (screenFrame.height * 0.08)
+            panel.setFrameOrigin(NSPoint(x: x, y: y))
+        }
+
+        self.panel = panel
+
+        panel.makeKeyAndOrderFront(nil)
+        NSApp.activate(ignoringOtherApps: true)
+        AppDelegate.updateActivationPolicy()
+    }
+
+    private func animateResize(width: CGFloat, height: CGFloat) {
+        guard let panel = panel, let screen = panel.screen ?? NSScreen.main else { return }
+
+        let screenFrame = screen.visibleFrame
+        // Clamp to screen bounds with margin
+        let newWidth = min(width, screenFrame.width * 0.92)
+        let newHeight = min(height, screenFrame.height * 0.85)
+
+        let newX = screenFrame.midX - newWidth / 2
+        let newY = screenFrame.midY - newHeight / 2 + (screenFrame.height * 0.08)
+
+        let newFrame = NSRect(x: newX, y: newY, width: newWidth, height: newHeight)
+
+        NSAnimationContext.runAnimationGroup { ctx in
+            ctx.duration = 0.25
+            ctx.timingFunction = CAMediaTimingFunction(name: .easeInEaseOut)
+            panel.animator().setFrame(newFrame, display: true)
+        }
+    }
+
+    func dismiss() {
+        isOpen = false
+        panel?.orderOut(nil)
+        panel = nil
+        AppDelegate.updateActivationPolicy()
+    }
+
+    /// Stretchable mask image for rounded corners
+    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/CommandPaletteView.swift

@@ -0,0 +1,307 @@
+import SwiftUI
+import AppKit
+
+struct CommandPaletteView: View {
+    let commands: [PaletteCommand]
+    let onDismiss: () -> Void
+
+    @State private var query = ""
+    @State private var selectedIndex = 0
+    @State private var eventMonitor: Any?
+    @FocusState private var isSearchFocused: Bool
+
+    private var filtered: [PaletteCommand] {
+        if query.isEmpty { return commands }
+        return commands
+            .map { ($0, $0.matchScore(query: query)) }
+            .filter { $0.1 > 0 }
+            .sorted { $0.1 > $1.1 }
+            .map(\.0)
+    }
+
+    /// Group commands by category (only used when query is empty)
+    private var grouped: [(PaletteCommand.Category, [PaletteCommand])] {
+        let items = filtered
+        var result: [(PaletteCommand.Category, [PaletteCommand])] = []
+        for cat in PaletteCommand.Category.allCases {
+            let group = items.filter { $0.category == cat }
+            if !group.isEmpty {
+                result.append((cat, group))
+            }
+        }
+        return result
+    }
+
+    var body: some View {
+        VStack(spacing: 0) {
+            // Search field
+            searchField
+
+            Rectangle()
+                .fill(Palette.border)
+                .frame(height: 0.5)
+
+            // Results
+            ScrollViewReader { proxy in
+                ScrollView {
+                    if query.isEmpty {
+                        groupedList
+                    } else {
+                        flatList
+                    }
+                }
+                .onChange(of: selectedIndex) { idx in
+                    let items = filtered
+                    if idx >= 0 && idx < items.count {
+                        proxy.scrollTo(items[idx].id, anchor: .center)
+                    }
+                }
+            }
+            .frame(minHeight: 280, maxHeight: 360)
+
+            Rectangle()
+                .fill(Palette.border)
+                .frame(height: 0.5)
+
+            // Footer hints
+            footer
+        }
+        .frame(width: 540)
+        .background(Palette.bg)
+        .clipShape(RoundedRectangle(cornerRadius: 14, style: .continuous))
+        .overlay(
+            RoundedRectangle(cornerRadius: 14, style: .continuous)
+                .strokeBorder(Palette.borderLit, lineWidth: 0.5)
+        )
+        .onAppear {
+            installKeyHandler()
+            // Delay focus slightly to ensure the panel is key
+            DispatchQueue.main.asyncAfter(deadline: .now() + 0.05) {
+                isSearchFocused = true
+            }
+        }
+        .onDisappear { removeKeyHandler() }
+    }
+
+    // MARK: - Search Field
+
+    private var searchField: some View {
+        HStack(spacing: 10) {
+            Image(systemName: "magnifyingglass")
+                .foregroundColor(Palette.textMuted)
+                .font(.system(size: 14))
+
+            TextField("Search commands...", text: $query)
+                .textFieldStyle(.plain)
+                .font(Typo.body(14))
+                .foregroundColor(Palette.text)
+                .focused($isSearchFocused)
+                .onChange(of: query) { _ in selectedIndex = 0 }
+        }
+        .padding(.horizontal, 16)
+        .padding(.vertical, 12)
+    }
+
+    // MARK: - Grouped List (empty query)
+
+    private var groupedList: some View {
+        LazyVStack(alignment: .leading, spacing: 0) {
+            ForEach(grouped, id: \.0) { category, items in
+                sectionHeader(category)
+                ForEach(items) { cmd in
+                    let idx = flatIndex(of: cmd)
+                    commandRow(cmd, isSelected: idx == selectedIndex)
+                        .id(cmd.id)
+                        .onTapGesture { executeCommand(cmd) }
+                }
+            }
+        }
+        .padding(.vertical, 6)
+    }
+
+    // MARK: - Flat List (with query)
+
+    private var flatList: some View {
+        LazyVStack(alignment: .leading, spacing: 0) {
+            ForEach(Array(filtered.enumerated()), id: \.element.id) { idx, cmd in
+                commandRow(cmd, isSelected: idx == selectedIndex)
+                    .id(cmd.id)
+                    .onTapGesture { executeCommand(cmd) }
+            }
+        }
+        .padding(.vertical, 6)
+    }
+
+    // MARK: - Section Header
+
+    private func sectionHeader(_ category: PaletteCommand.Category) -> some View {
+        HStack(spacing: 5) {
+            Image(systemName: category.icon)
+                .font(.system(size: 9))
+            Text(category.rawValue.uppercased())
+                .font(Typo.mono(9))
+        }
+        .foregroundColor(Palette.textMuted)
+        .padding(.horizontal, 16)
+        .padding(.top, 10)
+        .padding(.bottom, 4)
+    }
+
+    // MARK: - Command Row
+
+    private func commandRow(_ cmd: PaletteCommand, isSelected: Bool) -> some View {
+        HStack(spacing: 10) {
+            Image(systemName: cmd.icon)
+                .font(.system(size: 12))
+                .foregroundColor(isSelected ? Palette.text : Palette.textDim)
+                .frame(width: 20)
+
+            VStack(alignment: .leading, spacing: 1) {
+                HStack(spacing: 6) {
+                    Text(cmd.title)
+                        .font(Typo.body(13))
+                        .foregroundColor(isSelected ? Palette.text : Palette.text.opacity(0.85))
+                        .lineLimit(1)
+
+                    if let badge = cmd.badge {
+                        Text(badge)
+                            .font(Typo.mono(9))
+                            .foregroundColor(Palette.running)
+                            .padding(.horizontal, 5)
+                            .padding(.vertical, 1)
+                            .background(
+                                RoundedRectangle(cornerRadius: 3)
+                                    .fill(Palette.running.opacity(0.12))
+                            )
+                    }
+                }
+
+                Text(cmd.subtitle)
+                    .font(Typo.caption(10))
+                    .foregroundColor(Palette.textMuted)
+                    .lineLimit(1)
+            }
+
+            Spacer()
+        }
+        .padding(.horizontal, 14)
+        .padding(.vertical, 7)
+        .background(
+            RoundedRectangle(cornerRadius: 5)
+                .fill(isSelected ? Palette.surface : Color.clear)
+        )
+        .padding(.horizontal, 6)
+        .contentShape(Rectangle())
+    }
+
+    // MARK: - Footer
+
+    private var footer: some View {
+        HStack(spacing: 14) {
+            footerHint(keys: ["\u{2191}\u{2193}"], label: "navigate")
+            footerHint(keys: ["\u{21A9}"], label: "select")
+            footerHint(keys: ["esc"], label: "close")
+            Spacer()
+            Text("\(filtered.count) command\(filtered.count == 1 ? "" : "s")")
+                .font(Typo.mono(9))
+                .foregroundColor(Palette.textMuted)
+        }
+        .padding(.horizontal, 16)
+        .padding(.vertical, 8)
+        .background(Palette.surface.opacity(0.4))
+    }
+
+    private func footerHint(keys: [String], label: String) -> some View {
+        HStack(spacing: 4) {
+            ForEach(keys, id: \.self) { key in
+                Text(key)
+                    .font(Typo.mono(9))
+                    .foregroundColor(Palette.text)
+                    .padding(.horizontal, 4)
+                    .padding(.vertical, 2)
+                    .background(
+                        RoundedRectangle(cornerRadius: 3)
+                            .fill(Palette.surface)
+                            .overlay(
+                                RoundedRectangle(cornerRadius: 3)
+                                    .strokeBorder(Palette.border, lineWidth: 0.5)
+                            )
+                    )
+            }
+            Text(label)
+                .font(Typo.mono(9))
+                .foregroundColor(Palette.textMuted)
+        }
+    }
+
+    // MARK: - Keyboard Navigation
+
+    private func installKeyHandler() {
+        eventMonitor = NSEvent.addLocalMonitorForEvents(matching: .keyDown) { event in
+            let isSearchActive = isSearchFocused
+
+            switch Int(event.keyCode) {
+            case 125: // Down arrow
+                moveDown()
+                return nil
+            case 126: // Up arrow
+                moveUp()
+                return nil
+            case 38 where !isSearchActive: // j (vim down) — only when not typing
+                moveDown()
+                return nil
+            case 40 where !isSearchActive: // k (vim up) — only when not typing
+                moveUp()
+                return nil
+            case 36: // Return
+                let items = filtered
+                if selectedIndex >= 0 && selectedIndex < items.count {
+                    executeCommand(items[selectedIndex])
+                }
+                return nil
+            case 53: // Escape
+                onDismiss()
+                return nil
+            default:
+                return event
+            }
+        }
+    }
+
+    private func moveDown() {
+        let count = filtered.count
+        if count > 0 {
+            selectedIndex = min(selectedIndex + 1, count - 1)
+        }
+    }
+
+    private func moveUp() {
+        selectedIndex = max(selectedIndex - 1, 0)
+    }
+
+    private func removeKeyHandler() {
+        if let monitor = eventMonitor {
+            NSEvent.removeMonitor(monitor)
+            eventMonitor = nil
+        }
+    }
+
+    // MARK: - Execution
+
+    private func executeCommand(_ cmd: PaletteCommand) {
+        let action = cmd.action
+        onDismiss()
+        // Small delay to let the palette dismiss before executing
+        DispatchQueue.main.asyncAfter(deadline: .now() + 0.05) {
+            action()
+        }
+    }
+
+    // MARK: - Helpers
+
+    /// Get flat index of a command across all groups (for selection tracking)
+    private func flatIndex(of cmd: PaletteCommand) -> Int {
+        let items = filtered
+        return items.firstIndex(where: { $0.id == cmd.id }) ?? -1
+    }
+}

package/app/Sources/CommandPaletteWindow.swift

@@ -0,0 +1,134 @@
+import AppKit
+import SwiftUI
+
+/// NSPanel subclass that accepts key events even without a titlebar
+private class KeyablePanel: NSPanel {
+    override var canBecomeKey: Bool { true }
+    override var canBecomeMain: Bool { true }
+}
+
+final class CommandPaletteWindow {
+    static let shared = CommandPaletteWindow()
+
+    private var panel: NSPanel?
+    private var scanner: ProjectScanner?
+
+    func configure(scanner: ProjectScanner) {
+        self.scanner = scanner
+    }
+
+    var isVisible: Bool { panel?.isVisible ?? false }
+
+    func toggle() {
+        if let p = panel, p.isVisible {
+            dismiss()
+        } else {
+            show()
+        }
+    }
+
+    func show() {
+        // Always rebuild for fresh command state
+        dismiss()
+
+        guard let scanner = scanner else { return }
+
+        // Ensure projects are up to date (full scan if list is empty,
+        // e.g. palette opened via hotkey before main popover appeared)
+        if scanner.projects.isEmpty {
+            scanner.scan()
+        } else {
+            scanner.refreshStatus()
+        }
+
+        let commands = CommandBuilder.build(scanner: scanner)
+        let view = CommandPaletteView(commands: commands) { [weak self] in
+            self?.dismiss()
+        }
+        .preferredColorScheme(.dark)
+
+        let hosting = NSHostingView(rootView: view)
+        hosting.translatesAutoresizingMaskIntoConstraints = false
+
+        let panel = KeyablePanel(
+            contentRect: NSRect(x: 0, y: 0, width: 540, height: 440),
+            styleMask: [.nonactivatingPanel],
+            backing: .buffered,
+            defer: false
+        )
+
+        panel.isOpaque = false
+        panel.backgroundColor = .clear
+        panel.hasShadow = true
+        panel.level = .floating
+        panel.isMovableByWindowBackground = true
+        panel.hidesOnDeactivate = true
+        panel.collectionBehavior = [.canJoinAllSpaces, .fullScreenAuxiliary]
+        panel.isReleasedWhenClosed = false
+
+        // Use NSVisualEffectView as contentView with a maskImage to communicate
+        // the rounded shape to the window server (layer.cornerRadius only clips
+        // at the view level — the window backing store stays rectangular)
+        let cornerRadius: CGFloat = 14
+
+        let effectView = NSVisualEffectView()
+        effectView.blendingMode = .behindWindow
+        effectView.material = .popover
+        effectView.state = .active
+        effectView.wantsLayer = true
+        effectView.maskImage = Self.maskImage(cornerRadius: cornerRadius)
+
+        panel.contentView = effectView
+
+        effectView.addSubview(hosting)
+        NSLayoutConstraint.activate([
+            hosting.leadingAnchor.constraint(equalTo: effectView.leadingAnchor),
+            hosting.trailingAnchor.constraint(equalTo: effectView.trailingAnchor),
+            hosting.topAnchor.constraint(equalTo: effectView.topAnchor),
+            hosting.bottomAnchor.constraint(equalTo: effectView.bottomAnchor),
+        ])
+
+        // Center horizontally, slightly above vertical center (Spotlight-style)
+        if let screen = NSScreen.main {
+            let screenFrame = screen.visibleFrame
+            let x = screenFrame.midX - 270
+            let y = screenFrame.midY - 220 + (screenFrame.height * 0.1)
+            panel.setFrameOrigin(NSPoint(x: x, y: y))
+        }
+
+        panel.makeKeyAndOrderFront(nil)
+        NSApp.activate(ignoringOtherApps: true)
+
+        self.panel = panel
+        AppDelegate.updateActivationPolicy()
+    }
+
+    func dismiss() {
+        panel?.orderOut(nil)
+        panel = nil
+        AppDelegate.updateActivationPolicy()
+    }
+
+    /// Stretchable mask image for rounded corners — capInsets preserve the
+    /// corner arcs while the center stretches to any window size
+    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
+    }
+}