@lattices/cli 0.4.13 → 0.5.0

package/apps/mac/Sources/AppShell/HotkeyBootstrap.swift

@@ -1,87 +0,0 @@
-import AppKit
-
-enum HotkeyBootstrap {
-    static func registerHotkeys() {
-        let scanner = ProjectScanner.shared
-        CommandPaletteWindow.shared.configure(scanner: scanner)
-
-        let store = HotkeyStore.shared
-        store.register(action: .palette) { CommandPaletteWindow.shared.toggle() }
-        store.register(action: .unifiedWindow) { ScreenMapWindowController.shared.toggle() }
-        store.register(action: .bezel) { WorkspaceInspectorPresenter.show() }
-        store.register(action: .cheatSheet) { SettingsWindowController.shared.show() }
-        store.register(action: .desktopInventory) {
-            DiagnosticLog.shared.info("Hotkey: desktopInventory triggered")
-            ScreenMapWindowController.shared.showPage(.desktopInventory)
-        }
-        store.register(action: .voiceCommand) {
-            DiagnosticLog.shared.info("Hotkey: voiceCommand triggered")
-            VoiceCommandWindow.shared.toggle()
-        }
-        store.register(action: .handsOff) {
-            DiagnosticLog.shared.info("Hotkey: handsOff triggered")
-            HandsOffSession.shared.toggle()
-            if HandsOffSession.shared.state != .idle {
-                HUDController.shared.showVoiceBar()
-            } else {
-                HUDController.shared.hideVoiceBar()
-            }
-        }
-        store.register(action: .hud) { HUDController.shared.toggle() }
-        store.register(action: .mouseFinder) { MouseFinder.shared.find() }
-        store.register(action: .overlayActors) { ScreenOverlayCanvasController.shared.toggleAgentActorsVisibility() }
-        store.register(action: .omniSearch) { OmniSearchWindow.shared.toggle() }
-
-        registerLayerHotkeys(store: store)
-        registerTilingHotkeys(store: store)
-    }
-
-    private static func registerLayerHotkeys(store: HotkeyStore) {
-        store.register(action: .layerNext) { SessionLayerStore.shared.cycleNext() }
-        store.register(action: .layerPrev) { SessionLayerStore.shared.cyclePrev() }
-        store.register(action: .layerTag) { SessionLayerStore.shared.tagFrontmostWindow() }
-
-        let workspace = WorkspaceManager.shared
-        let configLayerCount = (workspace.config?.layers ?? []).count
-        let maxLayers = max(configLayerCount, 9)
-        for (index, action) in HotkeyAction.layerActions.prefix(maxLayers).enumerated() {
-            store.register(action: action) {
-                let session = SessionLayerStore.shared
-                if !session.layers.isEmpty && index < session.layers.count {
-                    session.switchTo(index: index)
-                } else {
-                    workspace.focusLayer(index: index)
-                }
-                EventBus.shared.post(.layerSwitched(index: index))
-            }
-        }
-    }
-
-    private static func registerTilingHotkeys(store: HotkeyStore) {
-        let tileMap: [(HotkeyAction, TilePosition)] = [
-            (.tileLeft, .left), (.tileRight, .right),
-            (.tileMaximize, .maximize), (.tileCenter, .center),
-            (.tileTopLeft, .topLeft), (.tileTopRight, .topRight),
-            (.tileBottomLeft, .bottomLeft), (.tileBottomRight, .bottomRight),
-            (.tileTop, .top), (.tileBottom, .bottom),
-            (.tileLeftThird, .leftThird), (.tileCenterThird, .centerThird),
-            (.tileRightThird, .rightThird),
-        ]
-        for (action, position) in tileMap {
-            store.register(action: action) {
-                WindowTiler.tileFrontmostViaAX(to: position)
-            }
-        }
-        store.register(action: .tileDistribute) {
-            WindowTiler.distributeVisible(reactivateLattices: false)
-        }
-        store.register(action: .tileTypeGrid) {
-            WindowTiler.distributeVisibleByFrontmostType(reactivateLattices: false)
-        }
-        store.register(action: .tileOrganize) {
-            let appName = DesktopModel.shared.frontmostWindow()?.app
-                ?? NSWorkspace.shared.frontmostApplication?.localizedName
-            CommandModeWindow.shared.show(launchMode: .organize(appName: appName))
-        }
-    }
-}

package/apps/mac/Sources/AppShell/KeyRecorderView.swift

@@ -1,210 +0,0 @@
-import SwiftUI
-import Carbon
-
-// MARK: - KeyRecorderView
-
-struct KeyRecorderView: View {
-    let action: HotkeyAction
-    @ObservedObject var store: HotkeyStore
-
-    @State private var isCapturing = false
-    @State private var conflictAction: HotkeyAction?
-    @State private var pendingBinding: KeyBinding?
-    @State private var showConflict = false
-
-    private var binding: KeyBinding? { store.bindings[action] }
-    private var isModified: Bool {
-        binding != HotkeyStore.defaultBindings[action]
-    }
-
-    var body: some View {
-        HStack(spacing: 8) {
-            // Action label
-            Text(action.label)
-                .font(Typo.caption(11))
-                .foregroundColor(Palette.textDim)
-                .frame(minWidth: 60, idealWidth: 90, alignment: .trailing)
-                .lineLimit(1)
-
-            // Key badges or capture prompt
-            if isCapturing {
-                Text("Press shortcut...")
-                    .font(Typo.mono(11))
-                    .foregroundColor(Palette.running)
-                    .frame(minWidth: 80, alignment: .leading)
-            } else if let binding = binding {
-                HStack(spacing: 4) {
-                    ForEach(binding.compactDisplayParts, id: \.self) { part in
-                        keyBadge(part)
-                    }
-                }
-                .frame(minWidth: 80, alignment: .leading)
-            }
-
-            Spacer()
-
-            // Edit button
-            Button {
-                if isCapturing {
-                    isCapturing = false
-                } else {
-                    isCapturing = true
-                }
-            } label: {
-                Text(isCapturing ? "Cancel" : "Edit")
-                    .font(Typo.caption(10))
-                    .foregroundColor(isCapturing ? Palette.kill : Palette.textDim)
-                    .padding(.horizontal, 8)
-                    .padding(.vertical, 3)
-                    .background(
-                        RoundedRectangle(cornerRadius: 3)
-                            .fill(Palette.surface)
-                            .overlay(
-                                RoundedRectangle(cornerRadius: 3)
-                                    .strokeBorder(Palette.border, lineWidth: 0.5)
-                            )
-                    )
-            }
-            .buttonStyle(.plain)
-
-            // Reset link (only when modified)
-            if isModified {
-                Button {
-                    store.resetBinding(for: action)
-                } label: {
-                    Text("Reset")
-                        .font(Typo.caption(10))
-                        .foregroundColor(Palette.detach)
-                }
-                .buttonStyle(.plain)
-            }
-        }
-        .padding(.vertical, 2)
-        .background(
-            isCapturing
-                ? KeyCaptureOverlay(onCapture: handleCapture, onCancel: { isCapturing = false })
-                : nil
-        )
-        .alert("Shortcut Conflict", isPresented: $showConflict) {
-            Button("Replace") {
-                if let pending = pendingBinding, let conflict = conflictAction {
-                    // Remove conflicting binding by resetting it
-                    store.resetBinding(for: conflict)
-                    store.updateBinding(for: action, to: pending)
-                }
-                pendingBinding = nil
-                conflictAction = nil
-                isCapturing = false
-            }
-            Button("Cancel", role: .cancel) {
-                pendingBinding = nil
-                conflictAction = nil
-            }
-        } message: {
-            if let conflict = conflictAction {
-                Text("This shortcut is already assigned to \"\(conflict.label)\". Replace it?")
-            }
-        }
-    }
-
-    private func handleCapture(_ binding: KeyBinding) {
-        if let conflict = store.conflicts(for: action, with: binding) {
-            pendingBinding = binding
-            conflictAction = conflict
-            showConflict = true
-        } else {
-            store.updateBinding(for: action, to: binding)
-            isCapturing = false
-        }
-    }
-
-    private func keyBadge(_ key: String) -> some View {
-        Text(key)
-            .font(Typo.geistMonoBold(10))
-            .foregroundColor(Palette.text)
-            .padding(.horizontal, 6)
-            .padding(.vertical, 3)
-            .background(
-                RoundedRectangle(cornerRadius: 3)
-                    .fill(Palette.surface)
-                    .overlay(
-                        RoundedRectangle(cornerRadius: 3)
-                            .strokeBorder(Palette.border, lineWidth: 0.5)
-                    )
-            )
-    }
-}
-
-// MARK: - KeyCaptureOverlay (NSViewRepresentable bridge)
-
-struct KeyCaptureOverlay: NSViewRepresentable {
-    let onCapture: (KeyBinding) -> Void
-    let onCancel: () -> Void
-
-    func makeNSView(context: Context) -> KeyCaptureNSView {
-        let view = KeyCaptureNSView()
-        view.onCapture = onCapture
-        view.onCancel = onCancel
-        return view
-    }
-
-    func updateNSView(_ nsView: KeyCaptureNSView, context: Context) {
-        nsView.onCapture = onCapture
-        nsView.onCancel = onCancel
-    }
-}
-
-class KeyCaptureNSView: NSView {
-    var onCapture: ((KeyBinding) -> Void)?
-    var onCancel: (() -> Void)?
-    private var monitor: Any?
-
-    override func viewDidMoveToWindow() {
-        super.viewDidMoveToWindow()
-        if window != nil {
-            startMonitoring()
-        } else {
-            stopMonitoring()
-        }
-    }
-
-    private func startMonitoring() {
-        stopMonitoring()
-        monitor = NSEvent.addLocalMonitorForEvents(matching: .keyDown) { [weak self] event in
-            guard let self = self else { return event }
-
-            // Escape cancels
-            if event.keyCode == 53 {
-                self.onCancel?()
-                return nil
-            }
-
-            // Require at least one modifier
-            let mods = event.modifierFlags.intersection([.command, .shift, .option, .control])
-            guard !mods.isEmpty else { return nil }
-
-            let keyCode = UInt32(event.keyCode)
-            let carbonMods = KeyBinding.carbonModifiers(from: mods)
-            let parts = KeyBinding.displayParts(keyCode: keyCode, carbonModifiers: carbonMods)
-
-            let binding = KeyBinding(
-                keyCode: keyCode,
-                carbonModifiers: carbonMods,
-                displayParts: parts
-            )
-            self.onCapture?(binding)
-            return nil // swallow the event
-        }
-    }
-
-    private func stopMonitoring() {
-        if let monitor = monitor {
-            NSEvent.removeMonitor(monitor)
-            self.monitor = nil
-        }
-    }
-
-    deinit {
-        stopMonitoring()
-    }
-}

package/apps/mac/Sources/AppShell/LatticesRuntime.swift

@@ -1,104 +0,0 @@
-import Foundation
-
-enum LatticesRuntime {
-    static var cliRoot: String? {
-        if let idx = CommandLine.arguments.firstIndex(of: "--lattices-cli-root"),
-           CommandLine.arguments.indices.contains(idx + 1) {
-            let root = CommandLine.arguments[idx + 1]
-            if hasAppHelper(in: root) { return root }
-        }
-
-        let bundleDerivedRoot = Bundle.main.bundleURL
-            .deletingLastPathComponent()
-            .deletingLastPathComponent()
-            .path
-        if hasAppHelper(in: bundleDerivedRoot) {
-            return bundleDerivedRoot
-        }
-
-        let devRoot = NSHomeDirectory() + "/dev/lattices"
-        if hasAppHelper(in: devRoot) {
-            return devRoot
-        }
-
-        return nil
-    }
-
-    static var appHelperScriptPath: String? {
-        guard let cliRoot else { return nil }
-        let path = cliRoot + "/bin/lattices-app.ts"
-        return FileManager.default.fileExists(atPath: path) ? path : nil
-    }
-
-    static var bunPath: String? {
-        let candidates = [
-            NSHomeDirectory() + "/.bun/bin/bun",
-            "/usr/local/bin/bun",
-            "/opt/homebrew/bin/bun",
-        ]
-        if let path = candidates.first(where: { FileManager.default.isExecutableFile(atPath: $0) }) {
-            return path
-        }
-
-        let resolved = ProcessQuery.shell(["/bin/zsh", "-lc", "command -v bun 2>/dev/null"])
-        if !resolved.isEmpty, FileManager.default.isExecutableFile(atPath: resolved) {
-            return resolved
-        }
-
-        return nil
-    }
-
-    static var appVersion: String {
-        let info = Bundle.main.infoDictionary
-        return (info?["CFBundleShortVersionString"] as? String)
-            ?? (info?["CFBundleVersion"] as? String)
-            ?? "unknown"
-    }
-
-    static var appDisplayVersion: String {
-        let base = appVersion == "unknown" ? "unknown" : "v\(appVersion)"
-        guard isDevBuild else { return base }
-
-        let track = buildTrack ?? "latest"
-        return "\(base)-dev.\(track)"
-    }
-
-    static var buildChannel: String {
-        let raw = Bundle.main.infoDictionary?["LatticesBuildChannel"] as? String
-        return raw?.trimmingCharacters(in: .whitespacesAndNewlines).lowercased() ?? "release"
-    }
-
-    static var buildTrack: String? {
-        normalizedInfoValue("LatticesBuildTrack")
-    }
-
-    static var buildRevision: String? {
-        normalizedInfoValue("LatticesBuildRevision")
-    }
-
-    static var buildTimestamp: String? {
-        normalizedInfoValue("LatticesBuildTimestamp")
-    }
-
-    static var isDevBuild: Bool {
-        buildChannel == "dev"
-    }
-
-    static var buildStatusLabel: String {
-        isDevBuild ? "Latest local dev build" : "Signed release build"
-    }
-
-    static var buildChannelLabel: String {
-        isDevBuild ? "DEV" : "RELEASE"
-    }
-
-    private static func hasAppHelper(in root: String) -> Bool {
-        FileManager.default.fileExists(atPath: root + "/bin/lattices-app.ts")
-    }
-
-    private static func normalizedInfoValue(_ key: String) -> String? {
-        guard let raw = Bundle.main.infoDictionary?[key] as? String else { return nil }
-        let value = raw.trimmingCharacters(in: .whitespacesAndNewlines)
-        return value.isEmpty || value == "unknown" ? nil : value
-    }
-}