@lattices/cli 0.4.10 → 0.4.12

package/app/Sources/AppShell/AppDelegate.swift

@@ -1,408 +0,0 @@
-import AppKit
-import Carbon
-import SwiftUI
-
-extension Notification.Name {
-    static let latticesPopoverWillShow = Notification.Name("latticesPopoverWillShow")
-}
-
-/// Manages the NSStatusItem (menu bar icon), left-click popover, and right-click context menu.
-/// Replaces the previous SwiftUI MenuBarExtra approach for full click-event control.
-class AppDelegate: NSObject, NSApplicationDelegate, NSPopoverDelegate {
-    private static weak var shared: AppDelegate?
-
-    private var statusItem: NSStatusItem!
-    private var popover: NSPopover?
-    private var contextMenu: NSMenu!
-
-    /// 3×3 grid icon for the menu bar — L-shape bright, rest dim (template for auto light/dark)
-    private static let menuBarIcon: NSImage = {
-        let size: CGFloat = 18
-        let img = NSImage(size: NSSize(width: size, height: size), flipped: true) { _ in
-            let pad: CGFloat = 2
-            let gap: CGFloat = 1.5
-            let cellSize = (size - 2 * pad - 2 * gap) / 3
-
-            let solidCells: Set<Int> = [0, 3, 6, 7, 8]
-
-            for row in 0..<3 {
-                for col in 0..<3 {
-                    let idx = row * 3 + col
-                    let x = pad + CGFloat(col) * (cellSize + gap)
-                    let y = pad + CGFloat(row) * (cellSize + gap)
-                    let rect = NSRect(x: x, y: y, width: cellSize, height: cellSize)
-
-                    if solidCells.contains(idx) {
-                        NSColor.black.setFill()
-                    } else {
-                        NSColor.black.withAlphaComponent(0.25).setFill()
-                    }
-                    let path = NSBezierPath(roundedRect: rect, xRadius: 0.8, yRadius: 0.8)
-                    path.fill()
-                }
-            }
-            return true
-        }
-        img.isTemplate = true
-        return img
-    }()
-
-    /// Toggle between .accessory (hidden from Dock/Cmd+Tab) and .regular (visible)
-    /// based on whether any managed windows are open.
-    static func updateActivationPolicy() {
-        let hasVisibleWindow =
-            (Self.shared?.popover?.isShown == true) ||
-            CommandModeWindow.shared.isVisible ||
-            CommandPaletteWindow.shared.isVisible ||
-            MainWindow.shared.isVisible ||
-            ScreenMapWindowController.shared.isVisible ||
-            OmniSearchWindow.shared.isVisible
-        let desired: NSApplication.ActivationPolicy = hasVisibleWindow ? .regular : .accessory
-        if NSApp.activationPolicy() != desired {
-            NSApp.setActivationPolicy(desired)
-            if desired == .regular {
-                NSApp.activate(ignoringOtherApps: true)
-            }
-        }
-    }
-
-    func applicationDidFinishLaunching(_ notification: Notification) {
-        Self.shared = self
-        NSApp.setActivationPolicy(.accessory)
-        NSApp.appearance = NSAppearance(named: .darkAqua)
-        registerDeepLinkHandler()
-
-        // --- Status item ---
-        statusItem = NSStatusBar.system.statusItem(withLength: NSStatusItem.squareLength)
-        if let button = statusItem.button {
-            button.image = Self.menuBarIcon
-            button.action = #selector(statusItemClicked(_:))
-            button.sendAction(on: [.leftMouseUp, .rightMouseUp])
-            button.target = self
-        }
-
-        // --- Context menu (right-click) ---
-        contextMenu = buildContextMenu()
-
-        // --- Hotkey registration ---
-        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) { Self.showWorkspaceInspector() }
-        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()
-            // Show voice bar when starting, hide when stopping
-            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() }
-
-        // Pre-render HUD panels off-screen for instant first open
-        DispatchQueue.main.async { HUDController.shared.warmUp() }
-        // Pre-build the menu bar popover so the first click doesn't pay the SwiftUI mount cost.
-        // Touching `.view` forces NSHostingController to materialize the SwiftUI view tree.
-        DispatchQueue.main.async { [weak self] in
-            guard let self = self else { return }
-            let p = self.makePopover()
-            _ = p.contentViewController?.view
-        }
-        store.register(action: .omniSearch) { OmniSearchWindow.shared.toggle() }
-        WindowDragSnapController.shared.start()
-        MouseGestureController.shared.start()
-        KeyboardRemapController.shared.start()
-
-        // Session layer cycling
-        store.register(action: .layerNext) { SessionLayerStore.shared.cycleNext() }
-        store.register(action: .layerPrev) { SessionLayerStore.shared.cyclePrev() }
-        store.register(action: .layerTag)  { SessionLayerStore.shared.tagFrontmostWindow() }
-
-        // Layer-switching hotkeys (1-9): session layers take priority
-        let workspace = WorkspaceManager.shared
-        let configLayerCount = (workspace.config?.layers ?? []).count
-        let maxLayers = max(configLayerCount, 9)
-        for (i, action) in HotkeyAction.layerActions.prefix(maxLayers).enumerated() {
-            let index = i
-            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))
-            }
-        }
-
-        // Tiling hotkeys
-        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))
-        }
-
-        // Onboarding on first launch; otherwise just check permissions
-        if !OnboardingWindowController.shared.showIfNeeded() {
-            PermissionChecker.shared.check()
-        }
-
-        // Start daemon services
-        let diag = DiagnosticLog.shared
-        let tBoot = diag.startTimed("Daemon services boot")
-        OcrStore.shared.open()
-        DesktopModel.shared.start()
-        OcrModel.shared.start()
-        TmuxModel.shared.start()
-        ProcessModel.shared.start()
-        LatticesApi.setup()
-        DaemonServer.shared.start()
-        if Preferences.shared.companionBridgeEnabled {
-            LatticesCompanionBridgeServer.shared.start()
-        } else {
-            diag.info("CompanionBridge: disabled by preference")
-        }
-        AgentPool.shared.start()
-        diag.finish(tBoot)
-
-        Task {
-            await AppUpdater.shared.checkIfNeeded()
-        }
-
-        // --diagnostics flag: auto-open diagnostics panel on launch
-        if CommandLine.arguments.contains("--diagnostics") {
-            DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) {
-                DiagnosticWindow.shared.show()
-            }
-        }
-
-        // --screen-map flag: auto-open layout on launch
-        if CommandLine.arguments.contains("--screen-map") {
-            DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) {
-                ScreenMapWindowController.shared.showPage(.screenMap)
-            }
-        }
-    }
-
-    func applicationWillTerminate(_ notification: Notification) {
-        KeyboardRemapController.shared.stop()
-        LatticesCompanionBridgeServer.shared.stop()
-        DaemonServer.shared.stop()
-    }
-
-    // MARK: - Status item click handler
-
-    @objc private func statusItemClicked(_ sender: Any?) {
-        guard let event = NSApp.currentEvent, let button = statusItem.button else { return }
-
-        if event.type == .rightMouseUp {
-            // Right-click → context menu
-            contextMenu.popUp(positioning: nil, at: NSPoint(x: 0, y: button.bounds.height + 4), in: button)
-        } else {
-            // Left-click → toggle the menu bar projects popover.
-            if let shown = popover, shown.isShown {
-                shown.performClose(sender)
-            } else {
-                showProjectsPopover()
-            }
-        }
-    }
-
-    /// Dismiss the popover programmatically (e.g. from the pop-out button).
-    func dismissPopover() {
-        popover?.performClose(nil)
-    }
-
-    /// Cached popover — built lazily on first click, reused on every subsequent open.
-    /// Keeping the SwiftUI view tree alive avoids rebuilding on each click (slow first paint).
-    /// Data refresh is driven from `popoverWillShow` + a notification MainView listens to.
-    private func makePopover() -> NSPopover {
-        if let p = popover { return p }
-        let t = DiagnosticLog.shared.startTimed("makePopover")
-        let p = NSPopover()
-        p.contentViewController = NSHostingController(rootView: MainView(scanner: ProjectScanner.shared))
-        p.behavior = .transient
-        p.contentSize = NSSize(width: 380, height: 300)
-        p.appearance = NSAppearance(named: .darkAqua)
-        p.delegate = self
-        popover = p
-        DiagnosticLog.shared.finish(t)
-        return p
-    }
-
-    private func showProjectsPopover() {
-        guard let button = statusItem.button else { return }
-        let p = makePopover()
-        p.show(relativeTo: button.bounds, of: button, preferredEdge: .minY)
-        p.contentViewController?.view.window?.makeKey()
-    }
-
-    func popoverWillShow(_ notification: Notification) {
-        Self.updateActivationPolicy()
-        NotificationCenter.default.post(name: .latticesPopoverWillShow, object: nil)
-    }
-
-    func popoverDidClose(_ notification: Notification) {
-        Self.updateActivationPolicy()
-    }
-
-    // MARK: - Context menu
-
-    private func buildContextMenu() -> NSMenu {
-        let menu = NSMenu()
-
-        let actions: [(String, String, Selector)] = [
-            ("Home", "", #selector(menuWorkspace)),
-            ("Layout", "", #selector(menuLayout)),
-            ("Search", "", #selector(menuSearch)),
-            ("Command Palette", "⌘⇧M", #selector(menuCommandPalette)),
-        ]
-        for (title, shortcut, action) in actions {
-            let item = NSMenuItem(title: title, action: action, keyEquivalent: "")
-            item.target = self
-            if !shortcut.isEmpty {
-                // Display-only; the actual hotkey is global
-            }
-            menu.addItem(item)
-        }
-
-        menu.addItem(.separator())
-
-        let cliActions: [(String, Selector)] = [
-            ("Projects…", #selector(menuProjects)),
-            ("Initialize Project in Terminal…", #selector(menuInitializeProject)),
-            ("Launch Project in Terminal…", #selector(menuLaunchProject)),
-        ]
-        for (title, action) in cliActions {
-            let item = NSMenuItem(title: title, action: action, keyEquivalent: "")
-            item.target = self
-            menu.addItem(item)
-        }
-
-        menu.addItem(.separator())
-
-        let update = NSMenuItem(title: "Update Lattices…", action: #selector(menuUpdate), keyEquivalent: "")
-        update.target = self
-        menu.addItem(update)
-
-        menu.addItem(.separator())
-
-        let settings = NSMenuItem(title: "Help & Settings…", action: #selector(menuSettings), keyEquivalent: ",")
-        settings.target = self
-        menu.addItem(settings)
-
-        menu.addItem(.separator())
-
-        let quit = NSMenuItem(title: "Quit Lattices", action: #selector(menuQuit), keyEquivalent: "q")
-        quit.target = self
-        menu.addItem(quit)
-
-        return menu
-    }
-
-    @objc private func menuCommandPalette() { CommandPaletteWindow.shared.toggle() }
-    @objc private func menuWorkspace() { ScreenMapWindowController.shared.showPage(.home) }
-    @objc private func menuLayout() { ScreenMapWindowController.shared.showPage(.screenMap) }
-    @objc private func menuSearch() { ScreenMapWindowController.shared.showPage(.desktopInventory) }
-    @objc private func menuDocs() { SettingsWindowController.shared.show() }
-    @objc private func menuProjects() { DispatchQueue.main.async { self.showProjectsPopover() } }
-    @objc private func menuInitializeProject() { CliActionLauncher.initializeProjectInTerminal() }
-    @objc private func menuLaunchProject() { CliActionLauncher.launchProjectInTerminal() }
-    @objc private func menuHUD() { HUDController.shared.toggle() }
-    @objc private func menuWindowBezel() { Self.showWorkspaceInspector() }
-    @objc private func menuCheatSheet() { SettingsWindowController.shared.show() }
-    @objc private func menuOmniSearch() { OmniSearchWindow.shared.toggle() }
-    @MainActor @objc private func menuUpdate() { AppUpdater.shared.promptForUpdate() }
-    @objc private func menuSettings() { SettingsWindowController.shared.show() }
-    @objc private func menuQuit() { NSApp.terminate(nil) }
-
-    // MARK: - Deep Links
-
-    private func registerDeepLinkHandler() {
-        NSAppleEventManager.shared().setEventHandler(
-            self,
-            andSelector: #selector(handleGetURLEvent(_:withReplyEvent:)),
-            forEventClass: AEEventClass(kInternetEventClass),
-            andEventID: AEEventID(kAEGetURL)
-        )
-    }
-
-    @objc private func handleGetURLEvent(
-        _ event: NSAppleEventDescriptor,
-        withReplyEvent replyEvent: NSAppleEventDescriptor
-    ) {
-        guard
-            let value = event.paramDescriptor(forKeyword: keyDirectObject)?.stringValue,
-            let url = URL(string: value)
-        else {
-            return
-        }
-        handleDeepLink(url)
-    }
-
-    private func handleDeepLink(_ url: URL) {
-        guard url.scheme?.localizedCaseInsensitiveCompare("lattices") == .orderedSame else {
-            return
-        }
-
-        let host = url.host?.lowercased()
-        let action = url.pathComponents
-            .first { $0 != "/" }?
-            .lowercased()
-
-        guard host == "companion" else {
-            SettingsWindowController.shared.show()
-            return
-        }
-
-        switch action {
-        case "enable", "start":
-            Preferences.shared.companionBridgeEnabled = true
-            SettingsWindowController.shared.showCompanion()
-        case "disable", "stop":
-            Preferences.shared.companionBridgeEnabled = false
-            SettingsWindowController.shared.showCompanion()
-        default:
-            SettingsWindowController.shared.showCompanion()
-        }
-    }
-
-    private static func showWorkspaceInspector() {
-        guard let entry = DesktopModel.shared.frontmostWindow(),
-              entry.app != "Lattices" else {
-            ScreenMapWindowController.shared.showPage(.screenMap)
-            return
-        }
-
-        ScreenMapWindowController.shared.showWindow(wid: entry.wid)
-    }
-}

package/app/Sources/Core/Input/KeyboardRemapController.swift

@@ -1,184 +0,0 @@
-import AppKit
-import Combine
-import CoreGraphics
-
-final class KeyboardRemapController {
-    static let shared = KeyboardRemapController()
-
-    private static let syntheticMarker: Int64 = 0x4C4B524D
-
-    private var eventTap: CFMachPort?
-    private var runLoopSource: CFRunLoopSource?
-    private var subscriptions: Set<AnyCancellable> = []
-    private var installedObservers = false
-    private var capsLayerActive = false
-    private var capsUsedAsModifier = false
-
-    private init() {}
-
-    func start() {
-        installObserversIfNeeded()
-        refresh()
-    }
-
-    func stop() {
-        removeEventTap()
-        capsLayerActive = false
-        capsUsedAsModifier = false
-    }
-
-    private func installObserversIfNeeded() {
-        guard !installedObservers else { return }
-        installedObservers = true
-
-        Preferences.shared.$keyboardRemapsEnabled
-            .receive(on: RunLoop.main)
-            .sink { [weak self] _ in self?.refresh() }
-            .store(in: &subscriptions)
-
-        PermissionChecker.shared.$accessibility
-            .receive(on: RunLoop.main)
-            .sink { [weak self] _ in self?.refresh() }
-            .store(in: &subscriptions)
-    }
-
-    private func refresh() {
-        guard Preferences.shared.keyboardRemapsEnabled,
-              PermissionChecker.shared.accessibility else {
-            removeEventTap()
-            return
-        }
-
-        KeyboardRemapStore.shared.ensureConfigFile()
-        if eventTap == nil {
-            installEventTap()
-        } else if let eventTap {
-            CGEvent.tapEnable(tap: eventTap, enable: true)
-        }
-    }
-
-    private func installEventTap() {
-        var mask = CGEventMask(0)
-        mask |= CGEventMask(1) << CGEventType.keyDown.rawValue
-        mask |= CGEventMask(1) << CGEventType.keyUp.rawValue
-        mask |= CGEventMask(1) << CGEventType.flagsChanged.rawValue
-
-        let tap = CGEvent.tapCreate(
-            tap: .cgSessionEventTap,
-            place: .headInsertEventTap,
-            options: .defaultTap,
-            eventsOfInterest: mask,
-            callback: Self.eventTapCallback,
-            userInfo: UnsafeMutableRawPointer(Unmanaged.passUnretained(self).toOpaque())
-        )
-
-        guard let tap else {
-            DiagnosticLog.shared.warn("KeyboardRemap: failed to install keyboard event tap")
-            return
-        }
-
-        let source = CFMachPortCreateRunLoopSource(kCFAllocatorDefault, tap, 0)
-        eventTap = tap
-        runLoopSource = source
-
-        if let source {
-            CFRunLoopAddSource(CFRunLoopGetMain(), source, .commonModes)
-        }
-        CGEvent.tapEnable(tap: tap, enable: true)
-        DiagnosticLog.shared.info("KeyboardRemap: keyboard event tap installed")
-    }
-
-    private func removeEventTap() {
-        if let source = runLoopSource {
-            CFRunLoopRemoveSource(CFRunLoopGetMain(), source, .commonModes)
-        }
-        runLoopSource = nil
-        if let tap = eventTap {
-            CFMachPortInvalidate(tap)
-        }
-        eventTap = nil
-    }
-
-    private static let eventTapCallback: CGEventTapCallBack = { _, type, event, userInfo in
-        guard let userInfo else { return Unmanaged.passUnretained(event) }
-        let controller = Unmanaged<KeyboardRemapController>.fromOpaque(userInfo).takeUnretainedValue()
-        return controller.handleEvent(type: type, event: event)
-    }
-
-    private func handleEvent(type: CGEventType, event: CGEvent) -> Unmanaged<CGEvent>? {
-        if type == .tapDisabledByTimeout || type == .tapDisabledByUserInput {
-            if let eventTap {
-                CGEvent.tapEnable(tap: eventTap, enable: true)
-            }
-            return Unmanaged.passUnretained(event)
-        }
-
-        if event.getIntegerValueField(.eventSourceUserData) == Self.syntheticMarker {
-            return Unmanaged.passUnretained(event)
-        }
-
-        KeyboardRemapStore.shared.reloadIfNeeded()
-        guard let rule = KeyboardRemapStore.shared.capsLockRule,
-              rule.toIfHeld == .hyper else {
-            return Unmanaged.passUnretained(event)
-        }
-
-        let keyCode = event.getIntegerValueField(.keyboardEventKeycode)
-        if type == .flagsChanged, keyCode == rule.from.keyCode {
-            return handleCapsLockFlagsChanged(event, rule: rule)
-        }
-
-        guard capsLayerActive else {
-            return Unmanaged.passUnretained(event)
-        }
-
-        switch type {
-        case .keyDown:
-            capsUsedAsModifier = true
-            event.flags = normalizedFlags(event.flags).union(.latticesHyper)
-            return Unmanaged.passUnretained(event)
-        case .keyUp:
-            event.flags = normalizedFlags(event.flags).union(.latticesHyper)
-            return Unmanaged.passUnretained(event)
-        default:
-            return Unmanaged.passUnretained(event)
-        }
-    }
-
-    private func handleCapsLockFlagsChanged(_ event: CGEvent, rule: KeyboardRemapRule) -> Unmanaged<CGEvent>? {
-        let isDown = event.flags.contains(.maskAlphaShift)
-        if isDown {
-            capsLayerActive = true
-            capsUsedAsModifier = false
-            DiagnosticLog.shared.info("KeyboardRemap: Caps Lock layer active")
-        } else {
-            let shouldTap = capsLayerActive && !capsUsedAsModifier && rule.toIfAlone == .escape
-            capsLayerActive = false
-            capsUsedAsModifier = false
-            if shouldTap {
-                postKeyTap(keyCode: 53)
-            }
-            DiagnosticLog.shared.info("KeyboardRemap: Caps Lock layer inactive")
-        }
-
-        return nil
-    }
-
-    private func normalizedFlags(_ flags: CGEventFlags) -> CGEventFlags {
-        var normalized = flags
-        normalized.remove(.maskAlphaShift)
-        return normalized
-    }
-
-    private func postKeyTap(keyCode: CGKeyCode) {
-        guard let source = CGEventSource(stateID: .combinedSessionState),
-              let down = CGEvent(keyboardEventSource: source, virtualKey: keyCode, keyDown: true),
-              let up = CGEvent(keyboardEventSource: source, virtualKey: keyCode, keyDown: false) else {
-            return
-        }
-        down.setIntegerValueField(.eventSourceUserData, value: Self.syntheticMarker)
-        up.setIntegerValueField(.eventSourceUserData, value: Self.syntheticMarker)
-        down.post(tap: .cghidEventTap)
-        up.post(tap: .cghidEventTap)
-    }
-}

package/app/Sources/Core/Input/KeyboardRemapStore.swift

@@ -1,84 +0,0 @@
-import AppKit
-import Combine
-import Foundation
-
-final class KeyboardRemapStore: ObservableObject {
-    static let shared = KeyboardRemapStore()
-
-    @Published private(set) var config: KeyboardRemapConfig
-
-    let configURL: URL
-    private var lastLoadedModifiedDate: Date?
-
-    private init() {
-        let dir = FileManager.default.homeDirectoryForCurrentUser
-            .appendingPathComponent(".lattices")
-        try? FileManager.default.createDirectory(at: dir, withIntermediateDirectories: true)
-        self.configURL = dir.appendingPathComponent("keyboard-remaps.json")
-        self.config = .defaults
-        ensureConfigFile()
-        reload()
-    }
-
-    var enabledRules: [KeyboardRemapRule] {
-        config.rules.filter(\.enabled)
-    }
-
-    var summaryLines: [String] {
-        enabledRules.map(\.summaryLine)
-    }
-
-    var capsLockRule: KeyboardRemapRule? {
-        enabledRules.first { $0.from == .capsLock }
-    }
-
-    func ensureConfigFile() {
-        guard !FileManager.default.fileExists(atPath: configURL.path) else { return }
-        write(config: .defaults)
-    }
-
-    func reload() {
-        guard let data = FileManager.default.contents(atPath: configURL.path) else {
-            config = .defaults
-            return
-        }
-
-        do {
-            config = try JSONDecoder().decode(KeyboardRemapConfig.self, from: data)
-            lastLoadedModifiedDate = modifiedDate()
-        } catch {
-            DiagnosticLog.shared.error("KeyboardRemapStore: failed to decode keyboard-remaps.json - \(error.localizedDescription)")
-            config = .defaults
-        }
-    }
-
-    func reloadIfNeeded() {
-        let currentModifiedDate = modifiedDate()
-        guard currentModifiedDate != lastLoadedModifiedDate else { return }
-        reload()
-    }
-
-    func restoreDefaults() {
-        write(config: .defaults)
-        reload()
-        DiagnosticLog.shared.info("Keyboard remaps restored to defaults")
-    }
-
-    func openConfiguration() {
-        ensureConfigFile()
-        NSWorkspace.shared.open(configURL)
-    }
-
-    private func write(config: KeyboardRemapConfig) {
-        let encoder = JSONEncoder()
-        encoder.outputFormatting = [.prettyPrinted, .sortedKeys, .withoutEscapingSlashes]
-        guard let data = try? encoder.encode(config) else { return }
-        try? data.write(to: configURL, options: .atomic)
-        lastLoadedModifiedDate = modifiedDate()
-    }
-
-    private func modifiedDate() -> Date? {
-        let attrs = try? FileManager.default.attributesOfItem(atPath: configURL.path)
-        return attrs?[.modificationDate] as? Date
-    }
-}