@lattices/cli 0.3.0 → 0.4.1

package/app/Sources/MouseFinder.swift

@@ -0,0 +1,222 @@
+import AppKit
+import CoreGraphics
+
+/// Locates the mouse cursor with an animated sonar pulse overlay.
+/// "Find" shows rings at the current cursor position.
+/// "Summon" warps the cursor to screen center (or a given point).
+final class MouseFinder {
+    static let shared = MouseFinder()
+
+    private var overlayWindows: [NSWindow] = []
+    private var dismissTimer: Timer?
+    private var animationTimer: Timer?
+    private var animationStart: CFTimeInterval = 0
+    private let animationDuration: CFTimeInterval = 1.5
+
+    // MARK: - Find (highlight current position)
+
+    func find() {
+        let pos = NSEvent.mouseLocation
+        showSonar(at: pos)
+    }
+
+    // MARK: - Summon (warp to center of the screen the mouse is on, or a specific point)
+
+    func summon(to point: CGPoint? = nil) {
+        let target: NSPoint
+        if let point {
+            target = point
+        } else {
+            let screen = mouseScreen()
+            let frame = screen.frame
+            target = NSPoint(x: frame.midX, y: frame.midY)
+        }
+
+        // CGWarpMouseCursorPosition uses top-left origin
+        let primaryHeight = NSScreen.screens.first?.frame.height ?? 0
+        let cgPoint = CGPoint(x: target.x, y: primaryHeight - target.y)
+        CGWarpMouseCursorPosition(cgPoint)
+        // Re-associate mouse with cursor position after warp
+        CGAssociateMouseAndMouseCursorPosition(1)
+
+        showSonar(at: target)
+    }
+
+    // MARK: - Sonar Animation
+
+    private func showSonar(at nsPoint: NSPoint) {
+        dismiss()
+
+        let screens = NSScreen.screens
+        guard !screens.isEmpty else { return }
+
+        let ringCount = 3
+        let maxRadius: CGFloat = 120
+        let totalSize = maxRadius * 2 + 20
+
+        for screen in screens {
+            // Only show on screens near the cursor
+            let extendedBounds = screen.frame.insetBy(dx: -maxRadius, dy: -maxRadius)
+            guard extendedBounds.contains(nsPoint) else { continue }
+
+            let windowFrame = NSRect(
+                x: nsPoint.x - totalSize / 2,
+                y: nsPoint.y - totalSize / 2,
+                width: totalSize,
+                height: totalSize
+            )
+
+            let window = NSWindow(
+                contentRect: windowFrame,
+                styleMask: .borderless,
+                backing: .buffered,
+                defer: false
+            )
+            window.isOpaque = false
+            window.backgroundColor = .clear
+            window.level = NSWindow.Level(rawValue: Int(CGWindowLevelForKey(.maximumWindow)))
+            window.hasShadow = false
+            window.ignoresMouseEvents = true
+            window.collectionBehavior = [.canJoinAllSpaces, .stationary]
+
+            let sonarView = SonarView(
+                frame: NSRect(origin: .zero, size: windowFrame.size),
+                ringCount: ringCount,
+                maxRadius: maxRadius
+            )
+            window.contentView = sonarView
+
+            window.alphaValue = 0
+            window.orderFrontRegardless()
+            overlayWindows.append(window)
+
+            // Fade in
+            NSAnimationContext.runAnimationGroup { ctx in
+                ctx.duration = 0.1
+                window.animator().alphaValue = 1.0
+            }
+        }
+
+        // Animate the rings expanding using CACurrentMediaTime for state
+        animationStart = CACurrentMediaTime()
+        let interval = 1.0 / 60.0
+
+        animationTimer = Timer.scheduledTimer(withTimeInterval: interval, repeats: true) { [weak self] timer in
+            guard let self else { timer.invalidate(); return }
+            let elapsed = CACurrentMediaTime() - self.animationStart
+            let progress = CGFloat(min(elapsed / self.animationDuration, 1.0))
+
+            for window in self.overlayWindows {
+                (window.contentView as? SonarView)?.progress = progress
+                window.contentView?.needsDisplay = true
+            }
+
+            if progress >= 1.0 {
+                timer.invalidate()
+                self.animationTimer = nil
+            }
+        }
+
+        // Auto-dismiss after animation + hold
+        dismissTimer = Timer.scheduledTimer(withTimeInterval: 2.5, repeats: false) { [weak self] _ in
+            self?.fadeOut()
+        }
+    }
+
+    private func fadeOut() {
+        let windows = overlayWindows
+        NSAnimationContext.runAnimationGroup({ ctx in
+            ctx.duration = 0.4
+            for window in windows {
+                window.animator().alphaValue = 0
+            }
+        }, completionHandler: { [weak self] in
+            self?.dismiss()
+        })
+    }
+
+    func dismiss() {
+        animationTimer?.invalidate()
+        animationTimer = nil
+        dismissTimer?.invalidate()
+        dismissTimer = nil
+        for window in overlayWindows {
+            window.orderOut(nil)
+        }
+        overlayWindows.removeAll()
+    }
+
+    private func mouseScreen() -> NSScreen {
+        let pos = NSEvent.mouseLocation
+        return NSScreen.screens.first(where: { $0.frame.contains(pos) }) ?? NSScreen.screens[0]
+    }
+}
+
+// MARK: - Sonar Ring View
+
+private class SonarView: NSView {
+    let ringCount: Int
+    let maxRadius: CGFloat
+    var progress: CGFloat = 0
+
+    init(frame: NSRect, ringCount: Int, maxRadius: CGFloat) {
+        self.ringCount = ringCount
+        self.maxRadius = maxRadius
+        super.init(frame: frame)
+    }
+
+    required init?(coder: NSCoder) { fatalError() }
+
+    override func draw(_ dirtyRect: NSRect) {
+        guard let ctx = NSGraphicsContext.current?.cgContext else { return }
+
+        let center = CGPoint(x: bounds.midX, y: bounds.midY)
+
+        // Draw rings from outermost to innermost
+        for i in 0..<ringCount {
+            let ringDelay = CGFloat(i) * 0.15
+            let denom = 1.0 - ringDelay * CGFloat(ringCount - 1) / CGFloat(ringCount)
+            let ringProgress = max(0, min(1, (progress - ringDelay) / denom))
+
+            guard ringProgress > 0 else { continue }
+
+            // Ease out cubic
+            let eased = 1.0 - pow(1.0 - ringProgress, 3)
+
+            let radius = maxRadius * eased
+            let alpha = (1.0 - eased) * 0.8
+
+            // Ring stroke
+            ctx.setStrokeColor(NSColor(calibratedRed: 0.4, green: 0.7, blue: 1.0, alpha: alpha).cgColor)
+            ctx.setLineWidth(2.5 - CGFloat(i) * 0.5)
+            ctx.addEllipse(in: CGRect(
+                x: center.x - radius,
+                y: center.y - radius,
+                width: radius * 2,
+                height: radius * 2
+            ))
+            ctx.strokePath()
+        }
+
+        // Center dot — stays visible
+        let dotRadius: CGFloat = 6
+        let dotAlpha = max(0.3, 1.0 - progress * 0.5)
+        ctx.setFillColor(NSColor(calibratedRed: 0.4, green: 0.7, blue: 1.0, alpha: dotAlpha).cgColor)
+        ctx.fillEllipse(in: CGRect(
+            x: center.x - dotRadius,
+            y: center.y - dotRadius,
+            width: dotRadius * 2,
+            height: dotRadius * 2
+        ))
+
+        // Outer glow on center dot
+        ctx.setFillColor(NSColor(calibratedRed: 0.4, green: 0.7, blue: 1.0, alpha: dotAlpha * 0.2).cgColor)
+        let glowRadius: CGFloat = 12
+        ctx.fillEllipse(in: CGRect(
+            x: center.x - glowRadius,
+            y: center.y - glowRadius,
+            width: glowRadius * 2,
+            height: glowRadius * 2
+        ))
+    }
+}

package/app/Sources/OcrModel.swift

@@ -60,8 +60,11 @@ final class OcrModel: ObservableObject {
             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)")
+        // Run initial scan immediately so search works right away
+        DispatchQueue.global(qos: .userInitiated).asyncAfter(deadline: .now() + 2) { [weak self] in
+            self?.quickScan()
+        }
         timer = Timer.scheduledTimer(withTimeInterval: self.interval, repeats: true) { [weak self] _ in
             guard let self, self.enabled else { return }
             self.quickScan()
@@ -90,6 +93,36 @@ final class OcrModel: ObservableObject {
         }
     }
 
+    // MARK: - Single Window Scan
+
+    /// Scan a single window by wid (AX extraction, instant).
+    func scanSingle(wid: UInt32) {
+        guard let entry = DesktopModel.shared.windows[wid] else { return }
+        queue.async { [weak self] in
+            guard let self else { return }
+            if let axResult = self.axExtractor.extract(pid: entry.pid, wid: wid) {
+                let blocks = axResult.texts.map { text in
+                    OcrTextBlock(text: text, confidence: 1.0, boundingBox: .zero)
+                }
+                let result = OcrWindowResult(
+                    wid: wid,
+                    app: entry.app,
+                    title: entry.title,
+                    frame: entry.frame,
+                    texts: blocks,
+                    fullText: axResult.fullText,
+                    timestamp: Date(),
+                    source: .accessibility
+                )
+                OcrStore.shared.insert(results: [result])
+                DispatchQueue.main.async {
+                    self.results[wid] = result
+                    DiagnosticLog.shared.info("OcrModel: single scan wid=\(wid) → \(axResult.texts.count) blocks")
+                }
+            }
+        }
+    }
+
     // MARK: - Scan
 
     /// Quick scan: AX-only text extraction for topmost windows (called every 60s).

package/app/Sources/OmniSearchState.swift

@@ -69,39 +69,110 @@ final class OmniSearchState: ObservableObject {
     private var debounceTimer: AnyCancellable?
 
     init() {
-        // Debounce search by 150ms
+        // Single-char queries fire immediately with a lightweight search;
+        // longer queries debounce 150ms and run the full search.
         debounceTimer = $query
-            .debounce(for: .milliseconds(150), scheduler: RunLoop.main)
+            .removeDuplicates()
             .sink { [weak self] q in
+                guard let self else { return }
+                self.fullSearchTask?.cancel()
                 if q.isEmpty {
-                    self?.results = []
-                    self?.refreshSummary()
+                    self.results = []
+                    self.refreshSummary()
+                } else if q.count == 1 {
+                    self.quickSearch(q)
                 } else {
-                    self?.search(q)
+                    self.fullSearchTask = DispatchWorkItem { [weak self] in
+                        self?.search(q)
+                    }
+                    DispatchQueue.main.asyncAfter(deadline: .now() + 0.15, execute: self.fullSearchTask!)
                 }
             }
 
         refreshSummary()
     }
 
-    // MARK: - Search
+    private var fullSearchTask: DispatchWorkItem?
+
+    // MARK: - Quick search (first character — window index only, no terminal/OCR/projects)
+
+    private func quickSearch(_ query: String) {
+        let q = query.lowercased()
+        let desktop = DesktopModel.shared
+        var all: [OmniResult] = []
+
+        for entry in desktop.allWindows() {
+            var score = 0
+            if entry.title.lowercased().contains(q) { score += 3 }
+            if entry.app.lowercased().contains(q) { score += 2 }
+            if entry.latticesSession?.lowercased().contains(q) == true { score += 3 }
+            guard score > 0 else { continue }
+
+            let wid = entry.wid
+            let pid = entry.pid
+            all.append(OmniResult(
+                kind: .window,
+                title: entry.app,
+                subtitle: entry.title.isEmpty ? "Window \(wid)" : entry.title,
+                icon: "macwindow",
+                score: score
+            ) {
+                WindowTiler.focusWindow(wid: wid, pid: pid)
+            })
+        }
+
+        all.sort { $0.score > $1.score }
+        results = Array(all.prefix(12))
+        selectedIndex = 0
+    }
+
+    // MARK: - Search (delegates to unified lattices.search API)
 
     private func search(_ query: String) {
         let q = query.lowercased()
         var all: [OmniResult] = []
 
-        // Windows
-        let desktop = DesktopModel.shared
-        for win in desktop.allWindows() {
-            let score = scoreMatch(q, against: [win.app, win.title])
-            if score > 0 {
-                let wid = win.wid
-                let pid = win.pid
+        // ── Daemon search: windows, terminals, OCR — single source of truth ──
+        // This is synchronous on the daemon's in-process API, not a network call.
+        if let json = try? LatticesApi.shared.dispatch(
+            method: "lattices.search",
+            params: .object(["query": .string(q)])
+        ), case .array(let hits) = json {
+            let desktop = DesktopModel.shared
+            for hit in hits {
+                guard let wid = hit["wid"]?.uint32Value else { continue }
+                let app = hit["app"]?.stringValue ?? ""
+                let title = hit["title"]?.stringValue ?? ""
+                let score = hit["score"]?.intValue ?? 0
+                let pid = desktop.windows[wid]?.pid ?? 0
+                let sources = (hit["matchSources"]?.arrayValue ?? []).compactMap(\.stringValue)
+
+                // Determine kind from match sources
+                let hasOcr = sources.contains("ocr")
+                let hasTerminal = !Set(sources).isDisjoint(with: ["cwd", "tab", "tmux", "process"])
+                let kind: OmniResultKind = hasOcr ? .ocrContent : hasTerminal ? .session : .window
+
+                let icon: String
+                let subtitle: String
+                switch kind {
+                case .ocrContent:
+                    icon = "doc.text.magnifyingglass"
+                    subtitle = hit["ocrSnippet"]?.stringValue ?? title
+                case .session:
+                    icon = "terminal"
+                    let tabs = hit["terminalTabs"]?.arrayValue ?? []
+                    let cwds = tabs.compactMap { $0["cwd"]?.stringValue }
+                    subtitle = cwds.first ?? title
+                default:
+                    icon = "macwindow"
+                    subtitle = title.isEmpty ? "Window \(wid)" : title
+                }
+
                 all.append(OmniResult(
-                    kind: .window,
-                    title: win.app,
-                    subtitle: win.title.isEmpty ? "Window \(win.wid)" : win.title,
-                    icon: "macwindow",
+                    kind: kind,
+                    title: app,
+                    subtitle: subtitle,
+                    icon: icon,
                     score: score
                 ) {
                     WindowTiler.focusWindow(wid: wid, pid: pid)
@@ -109,10 +180,9 @@ final class OmniSearchState: ObservableObject {
             }
         }
 
-        // Projects
-        let scanner = ProjectScanner.shared
-        for project in scanner.projects {
-            let score = scoreMatch(q, against: [project.name, project.path])
+        // ── Projects: local-only (not window-centric, so not in daemon search) ──
+        for project in ProjectScanner.shared.projects {
+            let score = scoreProjectMatch(q, name: project.name, path: project.path)
             if score > 0 {
                 let proj = project
                 all.append(OmniResult(
@@ -127,93 +197,20 @@ final class OmniSearchState: ObservableObject {
             }
         }
 
-        // Tmux Sessions
-        let tmux = TmuxModel.shared
-        for session in tmux.sessions {
-            let paneCommands = session.panes.map(\.currentCommand)
-            let score = scoreMatch(q, against: [session.name] + paneCommands)
-            if score > 0 {
-                let name = session.name
-                all.append(OmniResult(
-                    kind: .session,
-                    title: session.name,
-                    subtitle: "\(session.windowCount) windows, \(session.panes.count) panes\(session.attached ? " (attached)" : "")",
-                    icon: "terminal",
-                    score: score
-                ) {
-                    let terminal = Preferences.shared.terminal
-                    terminal.focusOrAttach(session: name)
-                })
-            }
-        }
-
-        // Processes
-        let processes = ProcessModel.shared
-        for proc in processes.interesting {
-            let score = scoreMatch(q, against: [proc.comm, proc.args, proc.cwd ?? ""])
-            if score > 0 {
-                all.append(OmniResult(
-                    kind: .process,
-                    title: proc.comm,
-                    subtitle: proc.cwd ?? proc.args,
-                    icon: "gearshape",
-                    score: score
-                ) {
-                    // No direct action for processes — just informational
-                })
-            }
-        }
-
-        // OCR content
-        let ocr = OcrModel.shared
-        for (_, result) in ocr.results {
-            let ocrScore = scoreOcr(q, fullText: result.fullText)
-            if ocrScore > 0 {
-                let wid = result.wid
-                let pid = desktop.windows[wid]?.pid ?? 0
-                // Find matching line for subtitle
-                let matchLine = result.texts
-                    .first { $0.text.lowercased().contains(q) }?
-                    .text ?? String(result.fullText.prefix(80))
-                all.append(OmniResult(
-                    kind: .ocrContent,
-                    title: "\(result.app) — \(result.title)",
-                    subtitle: matchLine,
-                    icon: "doc.text.magnifyingglass",
-                    score: ocrScore
-                ) {
-                    WindowTiler.focusWindow(wid: wid, pid: pid)
-                })
-            }
-        }
-
-        // Sort by score descending
         all.sort { $0.score > $1.score }
-
         results = all
         selectedIndex = 0
     }
 
-    // MARK: - Scoring
-
-    private func scoreMatch(_ query: String, against fields: [String]) -> Int {
-        var best = 0
-        for field in fields {
-            let lower = field.lowercased()
-            if lower == query {
-                best = max(best, 100)  // exact
-            } else if lower.hasPrefix(query) {
-                best = max(best, 80)   // prefix
-            } else if lower.contains(query) {
-                best = max(best, 60)   // contains
-            }
-        }
-        return best
-    }
+    // MARK: - Project scoring (local — projects aren't windows)
 
-    private func scoreOcr(_ query: String, fullText: String) -> Int {
-        let lower = fullText.lowercased()
-        if lower.contains(query) { return 40 }
+    private func scoreProjectMatch(_ query: String, name: String, path: String) -> Int {
+        let lowerName = name.lowercased()
+        let lowerPath = path.lowercased()
+        if lowerName == query { return 100 }
+        if lowerName.hasPrefix(query) { return 80 }
+        if lowerName.contains(query) { return 60 }
+        if lowerPath.contains(query) { return 40 }
         return 0
     }