@arach/lattices 0.1.0 → 0.2.1

package/app/Sources/MainView.swift

@@ -71,16 +71,7 @@ struct MainView: View {
                 Spacer()
 
                 headerButton(icon: "arrow.up.left.and.arrow.down.right") {
-                    // Dismiss the MenuBarExtra panel immediately
-                    for window in NSApp.windows {
-                        if window is NSPanel, window.isVisible,
-                           !CommandPaletteWindow.shared.isVisible || window.frame.width < 500 {
-                            // MenuBarExtra panels are small (~380px); command palette is 540px
-                            if window.frame.width <= 400 {
-                                window.orderOut(nil)
-                            }
-                        }
-                    }
+                    (NSApp.delegate as? AppDelegate)?.dismissPopover()
                     MainWindow.shared.show()
                 }
                 headerButton(icon: "arrow.clockwise") { scanner.scan(); inventory.refresh() }
@@ -190,8 +181,8 @@ struct MainView: View {
                 .fill(Palette.border)
                 .frame(height: 0.5)
 
-            // Status bar
-            statusBar
+            // Actions footer
+            actionsSection
         }
     }
 
@@ -253,96 +244,65 @@ struct MainView: View {
         }
     }
 
-    // MARK: - Status bar
+    // MARK: - Actions footer
 
-    private var statusBar: some View {
-        HStack(spacing: 0) {
-            // Settings button
-            Button { SettingsWindowController.shared.show() } label: {
-                Image(systemName: "gearshape")
-                    .font(.system(size: 10, weight: .medium))
-                    .foregroundColor(Palette.textMuted)
+    private var actionsSection: some View {
+        VStack(spacing: 0) {
+            ActionRow(shortcut: "1", label: "Command Palette", hotkey: hotkeyLabel(.palette), icon: "command", accentColor: Palette.running) {
+                CommandPaletteWindow.shared.toggle()
             }
-            .buttonStyle(.plain)
-            .help("Settings")
-
-            // Diagnostics toggle
-            Button { DiagnosticWindow.shared.toggle() } label: {
-                HStack(spacing: 3) {
-                    Image(systemName: "stethoscope")
-                        .font(.system(size: 10, weight: .medium))
-                        .foregroundColor(DiagnosticWindow.shared.isVisible ? Palette.running : Palette.textMuted)
-                    if !permChecker.allGranted {
-                        Circle()
-                            .fill(Palette.detach)
-                            .frame(width: 5, height: 5)
-                    }
-                }
+            ActionRow(shortcut: "2", label: "Screen Map", hotkey: hotkeyLabel(.screenMap), icon: "rectangle.3.group") {
+                ScreenMapWindowController.shared.toggle()
+            }
+            ActionRow(shortcut: "3", label: "Desktop Inventory", hotkey: hotkeyLabel(.desktopInventory), icon: "rectangle.split.2x1") {
+                CommandModeWindow.shared.toggle()
+            }
+            ActionRow(shortcut: "4", label: "Window Bezel", hotkey: hotkeyLabel(.bezel), icon: "macwindow") {
+                WindowBezel.showBezelForFrontmostWindow()
+            }
+            ActionRow(shortcut: "5", label: "Cheat Sheet", hotkey: hotkeyLabel(.cheatSheet), icon: "keyboard") {
+                CheatSheetHUD.shared.toggle()
+            }
+            ActionRow(shortcut: "6", label: "Omni Search", hotkey: hotkeyLabel(.omniSearch), icon: "magnifyingglass", accentColor: Palette.running) {
+                OmniSearchWindow.shared.toggle()
             }
-            .buttonStyle(.plain)
-            .help(!permChecker.allGranted ? "Permissions missing — open diagnostics" : "Toggle diagnostics")
 
             Rectangle()
                 .fill(Palette.border)
-                .frame(width: 0.5, height: 12)
-                .padding(.horizontal, 8)
-
-            // Config summary — keys dim, values white
-            statusLine
-
-            Spacer()
+                .frame(height: 0.5)
+                .padding(.horizontal, 10)
 
-            // Palette hint
-            Text("\u{2318}\u{21E7}M")
-                .font(Typo.mono(9))
-                .foregroundColor(Palette.textMuted)
-                .help("Command palette (Cmd+Shift+M)")
+            ActionRow(shortcut: "S", label: "Settings", icon: "gearshape") {
+                SettingsWindowController.shared.show()
+            }
+            HStack(spacing: 0) {
+                ActionRow(shortcut: "D", label: "Diagnostics", icon: "stethoscope") {
+                    DiagnosticWindow.shared.toggle()
+                }
+                if !permChecker.allGranted {
+                    Circle()
+                        .fill(Palette.detach)
+                        .frame(width: 6, height: 6)
+                        .padding(.trailing, 14)
+                }
+            }
 
             Rectangle()
                 .fill(Palette.border)
-                .frame(width: 0.5, height: 12)
-                .padding(.horizontal, 6)
+                .frame(height: 0.5)
+                .padding(.horizontal, 10)
 
-            // Quit
-            Button { NSApp.terminate(nil) } label: {
-                Image(systemName: "power")
-                    .font(.system(size: 9, weight: .medium))
-                    .foregroundColor(Palette.textMuted)
+            ActionRow(shortcut: "Q", label: "Quit", icon: "power", accentColor: Palette.kill) {
+                NSApp.terminate(nil)
             }
-            .buttonStyle(.plain)
-            .help("Quit lattices")
         }
-        .padding(.horizontal, 14)
-        .padding(.vertical, 7)
+        .padding(.vertical, 4)
         .background(Palette.surface.opacity(0.4))
     }
 
-    private var statusLine: some View {
-        HStack(spacing: 3) {
-            statusPair("terminal", prefs.terminal.rawValue.lowercased())
-            statusDot
-            statusPair("mode", prefs.mode.rawValue)
-            statusDot
-            statusPair("home", "~/\((prefs.scanRoot as NSString).lastPathComponent)")
-        }
-    }
-
-    private func statusPair(_ key: String, _ value: String) -> some View {
-        HStack(spacing: 3) {
-            Text(key + ":")
-                .font(Typo.mono(9))
-                .foregroundColor(Palette.textMuted)
-            Text(value)
-                .font(Typo.mono(9))
-                .foregroundColor(Palette.text)
-        }
-    }
-
-    private var statusDot: some View {
-        Circle()
-            .fill(Palette.textMuted)
-            .frame(width: 2, height: 2)
-            .padding(.horizontal, 4)
+    private func hotkeyLabel(_ action: HotkeyAction) -> String? {
+        guard let binding = HotkeyStore.shared.bindings[action] else { return nil }
+        return binding.displayParts.joined(separator: "")
     }
 
     // MARK: - Empty state

package/app/Sources/MainWindow.swift

@@ -7,6 +7,7 @@ final class MainWindow {
     static let shared = MainWindow()
 
     private var window: NSWindow?
+    private var keyMonitor: Any?
 
     var isVisible: Bool { window?.isVisible ?? false }
 
@@ -61,10 +62,22 @@ final class MainWindow {
 
         window = w
         AppDelegate.updateActivationPolicy()
+
+        // Escape key → close
+        keyMonitor = NSEvent.addLocalMonitorForEvents(matching: .keyDown) { [weak self] event in
+            guard event.keyCode == 53,
+                  self?.window?.isKeyWindow == true else { return event }
+            self?.close()
+            return nil
+        }
     }
 
     func close() {
         window?.orderOut(nil)
+        if let monitor = keyMonitor {
+            NSEvent.removeMonitor(monitor)
+            keyMonitor = nil
+        }
         AppDelegate.updateActivationPolicy()
     }
 }

package/app/Sources/OcrModel.swift

@@ -0,0 +1,309 @@
+import AppKit
+import CryptoKit
+import Vision
+
+// MARK: - Data Types
+
+struct OcrTextBlock {
+    let text: String
+    let confidence: Float         // 0.0–1.0
+    let boundingBox: CGRect       // normalized coordinates within window
+}
+
+struct OcrWindowResult {
+    let wid: UInt32
+    let app: String
+    let title: String
+    let frame: WindowFrame
+    let texts: [OcrTextBlock]
+    let fullText: String
+    let timestamp: Date
+}
+
+// MARK: - OCR Scanner
+
+final class OcrModel: ObservableObject {
+    static let shared = OcrModel()
+
+    @Published private(set) var results: [UInt32: OcrWindowResult] = [:]
+    @Published private(set) var isScanning: Bool = false
+    @Published var interval: TimeInterval = 60
+    @Published var enabled: Bool = true
+
+    private var timer: Timer?
+    private var deepTimer: Timer?
+    private let queue = DispatchQueue(label: "com.arach.lattices.ocr", qos: .background)
+    private var imageHashes: [UInt32: Data] = [:]
+    private var scanGeneration: Int = 0
+
+    private let myPid = ProcessInfo.processInfo.processIdentifier
+
+    private var prefs: Preferences { Preferences.shared }
+
+    func start(interval: TimeInterval? = nil) {
+        guard timer == nil else { return }
+        if let interval { self.interval = interval }
+        self.interval = prefs.ocrQuickInterval
+        self.enabled = prefs.ocrEnabled
+        guard enabled else {
+            DiagnosticLog.shared.info("OcrModel: disabled by user preference")
+            return
+        }
+        let deepInterval = prefs.ocrDeepInterval
+        // Defer initial scan — let the first timer tick handle it (grace period on launch)
+        DiagnosticLog.shared.info("OcrModel: starting (quick=\(self.interval)s/\(prefs.ocrQuickLimit)win, deep=\(deepInterval)s/\(prefs.ocrDeepLimit)win)")
+        timer = Timer.scheduledTimer(withTimeInterval: self.interval, repeats: true) { [weak self] _ in
+            guard let self, self.enabled else { return }
+            self.quickScan()
+        }
+        // Deep scan on a slower cadence
+        deepTimer = Timer.scheduledTimer(withTimeInterval: deepInterval, repeats: true) { [weak self] _ in
+            guard let self, self.enabled else { return }
+            self.scan()
+        }
+    }
+
+    func stop() {
+        timer?.invalidate()
+        timer = nil
+        deepTimer?.invalidate()
+        deepTimer = nil
+    }
+
+    func setEnabled(_ on: Bool) {
+        enabled = on
+        prefs.ocrEnabled = on
+        if on && timer == nil {
+            start()
+        } else if !on {
+            stop()
+        }
+    }
+
+    // MARK: - Scan
+
+    /// Quick scan: only the topmost frontmost windows (called every 60s)
+    func quickScan() {
+        scanWithLimit(prefs.ocrQuickLimit)
+    }
+
+    /// Deep scan: all visible windows (called every 2h, or manually via ocr.scan)
+    func scan() {
+        scanWithLimit(prefs.ocrDeepLimit)
+    }
+
+    private func scanWithLimit(_ limit: Int) {
+        guard !isScanning else { return }
+        DispatchQueue.main.async { self.isScanning = true }
+        scanGeneration += 1
+        let generation = scanGeneration
+
+        queue.async { [weak self] in
+            guard let self else { return }
+            var windows = self.enumerateWindows()
+
+            // Cap windows — CGWindowList returns front-to-back order,
+            // so prefix gives us the topmost/frontmost windows first
+            if windows.count > limit {
+                windows = Array(windows.prefix(limit))
+            }
+
+            // For quick scans, merge new results into existing rather than replacing
+            let previousResults = self.results
+            let fresh: [UInt32: OcrWindowResult] = limit < self.prefs.ocrDeepLimit ? previousResults : [:]
+            let newHashes: [UInt32: Data] = [:]
+            let totalBlocks = 0
+
+            self.processNextWindow(
+                windows: windows,
+                index: 0,
+                generation: generation,
+                previousResults: previousResults,
+                fresh: fresh,
+                newHashes: newHashes,
+                totalBlocks: totalBlocks,
+                changedResults: []
+            )
+        }
+    }
+
+    /// Process one window at a time, yielding back to the queue between each.
+    /// This lets GCD schedule higher-priority work between windows.
+    private func processNextWindow(
+        windows: [WindowEntry],
+        index: Int,
+        generation: Int,
+        previousResults: [UInt32: OcrWindowResult],
+        fresh: [UInt32: OcrWindowResult],
+        newHashes: [UInt32: Data],
+        totalBlocks: Int,
+        changedResults: [OcrWindowResult]
+    ) {
+        // Stale scan — a newer one started, abandon this one
+        guard generation == scanGeneration else {
+            DispatchQueue.main.async { self.isScanning = false }
+            return
+        }
+
+        // All windows processed — publish results & persist diffs
+        guard index < windows.count else {
+            self.imageHashes = newHashes
+
+            if !changedResults.isEmpty {
+                OcrStore.shared.insert(results: changedResults)
+            }
+
+            DispatchQueue.main.async {
+                self.results = fresh
+                self.isScanning = false
+            }
+
+            EventBus.shared.post(.ocrScanComplete(
+                windowCount: fresh.count,
+                totalBlocks: totalBlocks
+            ))
+            return
+        }
+
+        var fresh = fresh
+        var newHashes = newHashes
+        var totalBlocks = totalBlocks
+        var changedResults = changedResults
+
+        let win = windows[index]
+
+        if let cgImage = CGWindowListCreateImage(
+            .null,
+            .optionIncludingWindow,
+            CGWindowID(win.wid),
+            [.boundsIgnoreFraming, .bestResolution]
+        ) {
+            let hash = imageHash(cgImage)
+            newHashes[win.wid] = hash
+
+            if hash == imageHashes[win.wid], let prev = previousResults[win.wid] {
+                // Unchanged — reuse cached result
+                fresh[win.wid] = prev
+                totalBlocks += prev.texts.count
+            } else {
+                // Changed — run OCR
+                let blocks = recognizeText(in: cgImage)
+                let fullText = blocks.map(\.text).joined(separator: "\n")
+                totalBlocks += blocks.count
+
+                let result = OcrWindowResult(
+                    wid: win.wid,
+                    app: win.app,
+                    title: win.title,
+                    frame: win.frame,
+                    texts: blocks,
+                    fullText: fullText,
+                    timestamp: Date()
+                )
+                fresh[win.wid] = result
+                changedResults.append(result)
+            }
+        }
+
+        // Throttle: 100ms delay between windows to reduce CPU bursts
+        queue.asyncAfter(deadline: .now() + 0.1) { [weak self] in
+            self?.processNextWindow(
+                windows: windows,
+                index: index + 1,
+                generation: generation,
+                previousResults: previousResults,
+                fresh: fresh,
+                newHashes: newHashes,
+                totalBlocks: totalBlocks,
+                changedResults: changedResults
+            )
+        }
+    }
+
+    // MARK: - Window Enumeration
+
+    private func enumerateWindows() -> [WindowEntry] {
+        guard let list = CGWindowListCopyWindowInfo(
+            [.optionOnScreenOnly, .excludeDesktopElements],
+            kCGNullWindowID
+        ) as? [[String: Any]] else { return [] }
+
+        var entries: [WindowEntry] = []
+
+        for info in list {
+            guard let wid = info[kCGWindowNumber as String] as? UInt32,
+                  let ownerName = info[kCGWindowOwnerName as String] as? String,
+                  let pid = info[kCGWindowOwnerPID as String] as? Int32,
+                  let boundsDict = info[kCGWindowBounds as String] as? NSDictionary
+            else { continue }
+
+            // Skip own windows
+            guard pid != myPid else { continue }
+
+            var rect = CGRect.zero
+            guard CGRectMakeWithDictionaryRepresentation(boundsDict, &rect),
+                  rect.width >= 50, rect.height >= 50 else { continue }
+
+            let title = info[kCGWindowName as String] as? String ?? ""
+            let layer = info[kCGWindowLayer as String] as? Int ?? 0
+            guard layer == 0 else { continue }
+
+            let frame = WindowFrame(
+                x: Double(rect.origin.x),
+                y: Double(rect.origin.y),
+                w: Double(rect.width),
+                h: Double(rect.height)
+            )
+
+            entries.append(WindowEntry(
+                wid: wid,
+                app: ownerName,
+                pid: pid,
+                title: title,
+                frame: frame,
+                spaceIds: [],
+                isOnScreen: true,
+                latticesSession: nil
+            ))
+        }
+
+        return entries
+    }
+
+    // MARK: - Image Hashing
+
+    private func imageHash(_ image: CGImage) -> Data {
+        guard let dataProvider = image.dataProvider,
+              let data = dataProvider.data as Data? else {
+            return Data()
+        }
+        let digest = SHA256.hash(data: data as Data)
+        return Data(digest)
+    }
+
+    // MARK: - Vision OCR
+
+    private func recognizeText(in image: CGImage) -> [OcrTextBlock] {
+        let handler = VNImageRequestHandler(cgImage: image, options: [:])
+        let request = VNRecognizeTextRequest()
+        request.recognitionLevel = prefs.ocrAccuracy == "fast" ? .fast : .accurate
+        request.usesLanguageCorrection = true
+
+        do {
+            try handler.perform([request])
+        } catch {
+            return []
+        }
+
+        guard let observations = request.results else { return [] }
+
+        return observations.compactMap { obs in
+            guard let candidate = obs.topCandidates(1).first else { return nil }
+            return OcrTextBlock(
+                text: candidate.string,
+                confidence: candidate.confidence,
+                boundingBox: obs.boundingBox
+            )
+        }
+    }
+}