@lattices/cli 0.4.1 → 0.4.5

package/app/Sources/MouseInputDeviceStore.swift

@@ -0,0 +1,98 @@
+import Foundation
+import IOKit.hid
+
+struct MouseInputDeviceInfo: Identifiable, Equatable {
+    var id: String
+    var vendorId: Int?
+    var productId: Int?
+    var locationId: Int?
+    var product: String?
+    var manufacturer: String?
+    var transport: String?
+
+    var summary: String {
+        var parts: [String] = []
+        if let product, !product.isEmpty {
+            parts.append(product)
+        }
+        if let manufacturer, !manufacturer.isEmpty, parts.isEmpty {
+            parts.append(manufacturer)
+        }
+        if let vendorId { parts.append("vid:\(vendorId)") }
+        if let productId { parts.append("pid:\(productId)") }
+        if let locationId { parts.append("loc:\(locationId)") }
+        if let transport, !transport.isEmpty { parts.append(transport) }
+        return parts.isEmpty ? "Unknown pointer device" : parts.joined(separator: " | ")
+    }
+}
+
+final class MouseInputDeviceStore: ObservableObject {
+    static let shared = MouseInputDeviceStore()
+
+    @Published private(set) var devices: [MouseInputDeviceInfo] = []
+
+    private init() {
+        refresh()
+    }
+
+    func refresh() {
+        let manager = IOHIDManagerCreate(kCFAllocatorDefault, IOOptionBits(kIOHIDOptionsTypeNone))
+        let matches: [[String: Any]] = [
+            [
+                kIOHIDDeviceUsagePageKey as String: kHIDPage_GenericDesktop,
+                kIOHIDDeviceUsageKey as String: kHIDUsage_GD_Mouse,
+            ],
+            [
+                kIOHIDDeviceUsagePageKey as String: kHIDPage_GenericDesktop,
+                kIOHIDDeviceUsageKey as String: kHIDUsage_GD_Pointer,
+            ],
+        ]
+        IOHIDManagerSetDeviceMatchingMultiple(manager, matches as CFArray)
+        IOHIDManagerOpen(manager, IOOptionBits(kIOHIDOptionsTypeNone))
+
+        let resolved: [MouseInputDeviceInfo]
+        if let rawDevices = IOHIDManagerCopyDevices(manager) as? Set<IOHIDDevice> {
+            resolved = rawDevices.compactMap(Self.deviceInfo(for:))
+                .sorted { $0.summary.localizedCaseInsensitiveCompare($1.summary) == .orderedAscending }
+        } else {
+            resolved = []
+        }
+
+        DispatchQueue.main.async {
+            self.devices = resolved
+        }
+    }
+
+    private static func deviceInfo(for device: IOHIDDevice) -> MouseInputDeviceInfo? {
+        let vendorId = integerProperty(kIOHIDVendorIDKey as CFString, from: device)
+        let productId = integerProperty(kIOHIDProductIDKey as CFString, from: device)
+        let locationId = integerProperty(kIOHIDLocationIDKey as CFString, from: device)
+        let product = stringProperty(kIOHIDProductKey as CFString, from: device)
+        let manufacturer = stringProperty(kIOHIDManufacturerKey as CFString, from: device)
+        let transport = stringProperty(kIOHIDTransportKey as CFString, from: device)
+
+        let vendorToken = vendorId.map(String.init) ?? "vid"
+        let productToken = productId.map(String.init) ?? "pid"
+        let locationToken = locationId.map(String.init) ?? "loc"
+        let id = [product ?? "mouse", vendorToken, productToken, locationToken].joined(separator: ":")
+
+        return MouseInputDeviceInfo(
+            id: id,
+            vendorId: vendorId,
+            productId: productId,
+            locationId: locationId,
+            product: product,
+            manufacturer: manufacturer,
+            transport: transport
+        )
+    }
+
+    private static func integerProperty(_ key: CFString, from device: IOHIDDevice) -> Int? {
+        guard let value = IOHIDDeviceGetProperty(device, key) else { return nil }
+        return (value as? NSNumber)?.intValue
+    }
+
+    private static func stringProperty(_ key: CFString, from device: IOHIDDevice) -> String? {
+        IOHIDDeviceGetProperty(device, key) as? String
+    }
+}

package/app/Sources/MouseInputEventViewer.swift

@@ -0,0 +1,272 @@
+import AppKit
+import SwiftUI
+
+final class MouseInputEventViewer: ObservableObject {
+    static let shared = MouseInputEventViewer()
+
+    struct Entry: Identifiable {
+        let id = UUID()
+        let timestamp: Date
+        let phase: String
+        let appName: String
+        let bundleId: String
+        let buttonNumber: Int
+        let triggerCandidate: String
+        let deltaText: String
+        let modifiersText: String
+        let deviceText: String
+        let matchText: String
+        let note: String
+    }
+
+    @Published private(set) var entries: [Entry] = []
+    @Published private(set) var isCaptureActive = false
+
+    private let maxEntries = 120
+    private var window: NSWindow?
+    private var closeObserver: Any?
+
+    private init() {}
+
+    func show() {
+        if let window {
+            isCaptureActive = true
+            window.makeKeyAndOrderFront(nil)
+            NSApp.activate(ignoringOtherApps: true)
+            return
+        }
+
+        let view = MouseInputEventViewerView()
+        let window = AppWindowShell.makeWindow(
+            config: .init(
+                title: "Mouse Shortcut Event Viewer",
+                initialSize: NSSize(width: 980, height: 620),
+                minSize: NSSize(width: 840, height: 460),
+                maxSize: NSSize(width: 1500, height: 1000)
+            ),
+            rootView: view
+        )
+        AppWindowShell.positionCentered(window)
+        AppWindowShell.present(window)
+
+        closeObserver = NotificationCenter.default.addObserver(
+            forName: NSWindow.willCloseNotification,
+            object: window,
+            queue: .main
+        ) { [weak self] _ in
+            self?.teardownWindow()
+        }
+
+        self.window = window
+        isCaptureActive = true
+        DiagnosticLog.shared.info("Mouse shortcuts event viewer opened")
+    }
+
+    func dismiss() {
+        window?.close()
+        teardownWindow()
+    }
+
+    func clear() {
+        entries.removeAll()
+    }
+
+    func record(_ observedEvent: MouseShortcutObservedEvent) {
+        let entry = Entry(
+            timestamp: observedEvent.timestamp,
+            phase: observedEvent.phase,
+            appName: observedEvent.frontmostAppName ?? "Unknown App",
+            bundleId: observedEvent.frontmostBundleId ?? "unknown.bundle",
+            buttonNumber: observedEvent.buttonNumber,
+            triggerCandidate: observedEvent.candidateTrigger ?? "--",
+            deltaText: "\(Int(observedEvent.delta.x)), \(Int(observedEvent.delta.y))",
+            modifiersText: Self.modifierLabels(for: observedEvent.modifiers).joined(separator: "+").ifEmpty("--"),
+            deviceText: observedEvent.device?.summary ?? "Unresolved device",
+            matchText: observedEvent.matchedRuleSummary ?? (observedEvent.willFire ? "Would fire" : "No match"),
+            note: observedEvent.note ?? ""
+        )
+
+        DispatchQueue.main.async {
+            self.entries.append(entry)
+            if self.entries.count > self.maxEntries {
+                self.entries.removeFirst(self.entries.count - self.maxEntries)
+            }
+        }
+    }
+
+    private func teardownWindow() {
+        if let closeObserver {
+            NotificationCenter.default.removeObserver(closeObserver)
+            self.closeObserver = nil
+        }
+        window = nil
+        isCaptureActive = false
+    }
+
+    private static func modifierLabels(for flags: NSEvent.ModifierFlags) -> [String] {
+        var labels: [String] = []
+        if flags.contains(.control) { labels.append("Ctrl") }
+        if flags.contains(.option) { labels.append("Option") }
+        if flags.contains(.shift) { labels.append("Shift") }
+        if flags.contains(.command) { labels.append("Cmd") }
+        return labels
+    }
+}
+
+private struct MouseInputEventViewerView: View {
+    @ObservedObject private var viewer = MouseInputEventViewer.shared
+    @ObservedObject private var devices = MouseInputDeviceStore.shared
+
+    private static let timestampFormatter: DateFormatter = {
+        let formatter = DateFormatter()
+        formatter.dateFormat = "HH:mm:ss.SSS"
+        return formatter
+    }()
+
+    var body: some View {
+        VStack(spacing: 0) {
+            header
+            Divider()
+                .overlay(Color.white.opacity(0.08))
+            ScrollView {
+                LazyVStack(alignment: .leading, spacing: 8) {
+                    if devices.devices.isEmpty {
+                        deviceStrip(text: "Devices: none detected")
+                    } else {
+                        deviceStrip(text: "Devices: " + devices.devices.map(\.summary).joined(separator: "  |  "))
+                    }
+
+                    ForEach(viewer.entries) { entry in
+                        entryRow(entry)
+                    }
+                }
+                .padding(14)
+            }
+            .background(Color.black.opacity(0.16))
+        }
+    }
+
+    private var header: some View {
+        HStack(spacing: 12) {
+            VStack(alignment: .leading, spacing: 4) {
+                Text("Mouse Shortcut Event Viewer")
+                    .font(.system(size: 14, weight: .semibold, design: .monospaced))
+                    .foregroundColor(.white.opacity(0.95))
+                Text("Watching extra mouse buttons and drag candidates for configurable shortcuts.")
+                    .font(.system(size: 11))
+                    .foregroundColor(.white.opacity(0.6))
+            }
+
+            Spacer()
+
+            Button("Copy") {
+                let text = viewer.entries.map { entry in
+                    [
+                        Self.timestampFormatter.string(from: entry.timestamp),
+                        entry.phase,
+                        entry.appName,
+                        entry.bundleId,
+                        "button=\(entry.buttonNumber)",
+                        "candidate=\(entry.triggerCandidate)",
+                        "delta=\(entry.deltaText)",
+                        "mods=\(entry.modifiersText)",
+                        "device=\(entry.deviceText)",
+                        "match=\(entry.matchText)",
+                        entry.note,
+                    ].filter { !$0.isEmpty }.joined(separator: " | ")
+                }.joined(separator: "\n")
+                NSPasteboard.general.clearContents()
+                NSPasteboard.general.setString(text, forType: .string)
+            }
+            .buttonStyle(.plain)
+            .foregroundColor(.white.opacity(0.72))
+
+            Button("Clear") {
+                viewer.clear()
+            }
+            .buttonStyle(.plain)
+            .foregroundColor(.white.opacity(0.72))
+        }
+        .padding(.horizontal, 16)
+        .padding(.vertical, 12)
+        .background(Color.white.opacity(0.04))
+    }
+
+    private func deviceStrip(text: String) -> some View {
+        Text(text)
+            .font(.system(size: 10, weight: .medium, design: .monospaced))
+            .foregroundColor(.white.opacity(0.6))
+            .padding(.horizontal, 10)
+            .padding(.vertical, 8)
+            .frame(maxWidth: .infinity, alignment: .leading)
+            .background(
+                RoundedRectangle(cornerRadius: 10)
+                    .fill(Color.white.opacity(0.04))
+            )
+    }
+
+    private func entryRow(_ entry: MouseInputEventViewer.Entry) -> some View {
+        VStack(alignment: .leading, spacing: 6) {
+            HStack(alignment: .firstTextBaseline, spacing: 10) {
+                Text(Self.timestampFormatter.string(from: entry.timestamp))
+                    .font(.system(size: 11, weight: .medium, design: .monospaced))
+                    .foregroundColor(.white.opacity(0.82))
+
+                Text(entry.phase.uppercased())
+                    .font(.system(size: 10, weight: .bold, design: .monospaced))
+                    .foregroundColor(Color(red: 0.62, green: 0.84, blue: 1.0))
+
+                Text(entry.triggerCandidate)
+                    .font(.system(size: 11, weight: .semibold, design: .monospaced))
+                    .foregroundColor(.white.opacity(0.94))
+
+                Spacer()
+
+                Text(entry.matchText)
+                    .font(.system(size: 10, weight: .medium, design: .monospaced))
+                    .foregroundColor(.white.opacity(0.68))
+            }
+
+            HStack(spacing: 14) {
+                metadataPill("App", "\(entry.appName) (\(entry.bundleId))")
+                metadataPill("Button", "\(entry.buttonNumber)")
+                metadataPill("Delta", entry.deltaText)
+                metadataPill("Mods", entry.modifiersText)
+            }
+
+            HStack(spacing: 14) {
+                metadataPill("Device", entry.deviceText)
+                if !entry.note.isEmpty {
+                    metadataPill("Note", entry.note)
+                }
+            }
+        }
+        .padding(12)
+        .frame(maxWidth: .infinity, alignment: .leading)
+        .background(
+            RoundedRectangle(cornerRadius: 12)
+                .fill(Color.white.opacity(0.04))
+                .overlay(
+                    RoundedRectangle(cornerRadius: 12)
+                        .stroke(Color.white.opacity(0.06), lineWidth: 0.5)
+                )
+        )
+    }
+
+    private func metadataPill(_ label: String, _ value: String) -> some View {
+        HStack(spacing: 6) {
+            Text(label.uppercased())
+                .font(.system(size: 9, weight: .bold, design: .monospaced))
+                .foregroundColor(.white.opacity(0.42))
+            Text(value)
+                .font(.system(size: 10, weight: .medium, design: .monospaced))
+                .foregroundColor(.white.opacity(0.82))
+        }
+    }
+}
+
+private extension String {
+    func ifEmpty(_ replacement: String) -> String {
+        isEmpty ? replacement : self
+    }
+}

package/app/Sources/MouseShortcutStore.swift

@@ -0,0 +1,107 @@
+import AppKit
+import Combine
+import Foundation
+
+final class MouseShortcutStore: ObservableObject {
+    static let shared = MouseShortcutStore()
+
+    @Published private(set) var config: MouseShortcutConfig
+
+    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("mouse-shortcuts.json")
+        self.config = .defaults
+        ensureConfigFile()
+        reload()
+    }
+
+    var tuning: MouseShortcutTuning {
+        config.tuning
+    }
+
+    var enabledRules: [MouseShortcutRule] {
+        config.rules.filter(\.enabled)
+    }
+
+    var watchedButtonNumbers: Set<Int64> {
+        Set(enabledRules.map { Int64($0.trigger.button.rawButtonNumber) })
+    }
+
+    var summaryLines: [String] {
+        enabledRules.map { "\($0.trigger.triggerName) -> \($0.action.type.rawValue)" }
+    }
+
+    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(MouseShortcutConfig.self, from: data)
+            lastLoadedModifiedDate = modifiedDate()
+        } catch {
+            DiagnosticLog.shared.error("MouseShortcutStore: failed to decode mouse-shortcuts.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("Mouse shortcuts restored to defaults")
+    }
+
+    func openConfiguration() {
+        ensureConfigFile()
+        NSWorkspace.shared.open(configURL)
+    }
+
+    func match(for event: MouseShortcutTriggerEvent) -> MouseShortcutMatchResult? {
+        for rule in enabledRules {
+            guard rule.trigger.kind == event.kind,
+                  rule.trigger.button == event.button,
+                  rule.trigger.direction == event.direction,
+                  rule.device.matches(event.device) else {
+                continue
+            }
+
+            return MouseShortcutMatchResult(
+                rule: rule,
+                action: rule.action,
+                triggerName: rule.trigger.triggerName
+            )
+        }
+
+        return nil
+    }
+
+    private func write(config: MouseShortcutConfig) {
+        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
+    }
+}

package/app/Sources/OmniSearchView.swift

@@ -3,7 +3,10 @@ import SwiftUI
 struct OmniSearchView: View {
     @ObservedObject var state: OmniSearchState
     var onDismiss: () -> Void
+    var isEmbedded: Bool = false
 
+    @ObservedObject private var ocrModel = OcrModel.shared
+    @State private var expandedOcrWindow: UInt32?
     @FocusState private var searchFocused: Bool
 
     var body: some View {
@@ -46,8 +49,22 @@ struct OmniSearchView: View {
                 resultsView
             }
         }
-        .frame(minWidth: 520, idealWidth: 520, maxWidth: 700, minHeight: 360, idealHeight: 480, maxHeight: 600)
-        .background(PanelBackground())
+        .frame(
+            minWidth: isEmbedded ? 0 : 520,
+            idealWidth: isEmbedded ? nil : 520,
+            maxWidth: isEmbedded ? .infinity : 700,
+            minHeight: isEmbedded ? 0 : 360,
+            idealHeight: isEmbedded ? nil : 480,
+            maxHeight: isEmbedded ? .infinity : 600,
+            alignment: .top
+        )
+        .background {
+            if isEmbedded {
+                Palette.bg
+            } else {
+                PanelBackground()
+            }
+        }
         .preferredColorScheme(.dark)
         .onAppear {
             searchFocused = true
@@ -234,6 +251,10 @@ struct OmniSearchView: View {
                         }
                         .padding(.horizontal, 14)
                     }
+
+                    if !recentOcrResults.isEmpty {
+                        ocrResultsSection
+                    }
                 } else {
                     Text("Loading...")
                         .font(Typo.mono(11))
@@ -245,6 +266,105 @@ struct OmniSearchView: View {
         }
     }
 
+    private var recentOcrResults: [OcrWindowResult] {
+        Array(ocrModel.results.values.sorted { $0.timestamp > $1.timestamp }.prefix(10))
+    }
+
+    private var ocrResultsSection: some View {
+        summarySection("SCREEN TEXT", icon: "doc.text.magnifyingglass", count: ocrModel.results.count) {
+            ForEach(recentOcrResults, id: \.wid) { result in
+                ocrResultRow(result)
+            }
+        }
+    }
+
+    private func ocrResultRow(_ result: OcrWindowResult) -> some View {
+        let isExpanded = expandedOcrWindow == result.wid
+        let title = result.title.isEmpty ? "Untitled" : result.title
+        let preview = compactPreview(result.fullText)
+
+        return VStack(alignment: .leading, spacing: 5) {
+            Button {
+                withAnimation(.easeOut(duration: 0.12)) {
+                    expandedOcrWindow = isExpanded ? nil : result.wid
+                }
+            } label: {
+                VStack(alignment: .leading, spacing: 4) {
+                    HStack(spacing: 7) {
+                        Image(systemName: isExpanded ? "chevron.down" : "chevron.right")
+                            .font(.system(size: 8, weight: .semibold))
+                            .foregroundColor(Palette.textMuted)
+                            .frame(width: 9)
+
+                        Text(result.app)
+                            .font(Typo.monoBold(11))
+                            .foregroundColor(Palette.textDim)
+                            .lineLimit(1)
+
+                        Text(sourceLabel(result.source))
+                            .font(Typo.mono(8))
+                            .foregroundColor(Palette.textMuted)
+                            .padding(.horizontal, 4)
+                            .padding(.vertical, 1)
+                            .background(
+                                RoundedRectangle(cornerRadius: 3)
+                                    .fill(Palette.surface.opacity(0.8))
+                            )
+
+                        Spacer()
+
+                        Text(relativeTime(result.timestamp))
+                            .font(Typo.mono(9))
+                            .foregroundColor(Palette.textMuted)
+                    }
+
+                    Text(title)
+                        .font(Typo.mono(10))
+                        .foregroundColor(Palette.textMuted)
+                        .lineLimit(1)
+
+                    if !isExpanded && !preview.isEmpty {
+                        Text(preview)
+                            .font(Typo.mono(9))
+                            .foregroundColor(Palette.textMuted.opacity(0.75))
+                            .lineLimit(2)
+                    }
+                }
+                .padding(8)
+                .background(
+                    RoundedRectangle(cornerRadius: 5)
+                        .fill(Palette.surface.opacity(isExpanded ? 0.72 : 0.38))
+                        .overlay(
+                            RoundedRectangle(cornerRadius: 5)
+                                .strokeBorder(Color.white.opacity(isExpanded ? 0.10 : 0.05), lineWidth: 0.5)
+                        )
+                )
+                .contentShape(Rectangle())
+            }
+            .buttonStyle(.plain)
+
+            if isExpanded {
+                ScrollView {
+                    Text(result.fullText.isEmpty ? "No text captured." : result.fullText)
+                        .font(Typo.mono(10))
+                        .foregroundColor(Palette.textDim)
+                        .textSelection(.enabled)
+                        .frame(maxWidth: .infinity, alignment: .leading)
+                        .padding(8)
+                }
+                .frame(maxHeight: 140)
+                .background(
+                    RoundedRectangle(cornerRadius: 5)
+                        .fill(Color.black.opacity(0.22))
+                        .overlay(
+                            RoundedRectangle(cornerRadius: 5)
+                                .strokeBorder(Color.white.opacity(0.06), lineWidth: 0.5)
+                        )
+                )
+            }
+        }
+    }
+
     private func summarySection<Content: View>(
         _ title: String,
         icon: String,
@@ -285,4 +405,18 @@ struct OmniSearchView: View {
         if seconds < 3600 { return "\(seconds / 60)m ago" }
         return "\(seconds / 3600)h ago"
     }
+
+    private func sourceLabel(_ source: TextSource) -> String {
+        switch source {
+        case .accessibility: return "AX"
+        case .ocr: return "OCR"
+        }
+    }
+
+    private func compactPreview(_ text: String) -> String {
+        text
+            .components(separatedBy: .whitespacesAndNewlines)
+            .filter { !$0.isEmpty }
+            .joined(separator: " ")
+    }
 }