@arach/lattices 0.1.0 → 0.2.0

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
+            )
+        }
+    }
+}

package/app/Sources/OcrStore.swift

@@ -0,0 +1,295 @@
+import Foundation
+import SQLite3
+
+// MARK: - Search Result
+
+struct OcrSearchResult {
+    let id: Int64
+    let wid: UInt32
+    let app: String
+    let title: String
+    let frame: WindowFrame
+    let fullText: String
+    let snippet: String
+    let timestamp: Date
+}
+
+// MARK: - SQLite OCR Store
+
+final class OcrStore {
+    static let shared = OcrStore()
+
+    private var db: OpaquePointer?
+    private let queue = DispatchQueue(label: "com.arach.lattices.ocrstore", qos: .background)
+
+    // Cached prepared statements
+    private var insertStmt: OpaquePointer?
+    private var cleanupStmt: OpaquePointer?
+
+    private let sqliteTransient = unsafeBitCast(-1, to: sqlite3_destructor_type.self)
+
+    // MARK: - Open / Schema
+
+    func open() {
+        queue.sync {
+            guard db == nil else { return }
+
+            let dir = NSHomeDirectory() + "/.lattices"
+            try? FileManager.default.createDirectory(atPath: dir, withIntermediateDirectories: true)
+            let path = dir + "/ocr.db"
+
+            guard sqlite3_open_v2(path, &db, SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE | SQLITE_OPEN_FULLMUTEX, nil) == SQLITE_OK else {
+                DiagnosticLog.shared.error("OcrStore: failed to open \(path)")
+                return
+            }
+
+            // WAL mode for concurrent reads/writes
+            exec("PRAGMA journal_mode=WAL")
+            exec("PRAGMA synchronous=NORMAL")
+
+            // Main table
+            exec("""
+                CREATE TABLE IF NOT EXISTS ocr_entry (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    wid INTEGER NOT NULL,
+                    app TEXT NOT NULL,
+                    title TEXT NOT NULL,
+                    frame_x REAL,
+                    frame_y REAL,
+                    frame_w REAL,
+                    frame_h REAL,
+                    full_text TEXT NOT NULL,
+                    timestamp REAL NOT NULL
+                )
+            """)
+            exec("CREATE INDEX IF NOT EXISTS idx_ocr_entry_timestamp ON ocr_entry(timestamp)")
+            exec("CREATE INDEX IF NOT EXISTS idx_ocr_entry_wid ON ocr_entry(wid)")
+
+            // FTS5 content-sync table
+            exec("""
+                CREATE VIRTUAL TABLE IF NOT EXISTS ocr_fts USING fts5(
+                    full_text, app, title,
+                    content='ocr_entry', content_rowid='id'
+                )
+            """)
+
+            // Triggers to keep FTS in sync
+            exec("""
+                CREATE TRIGGER IF NOT EXISTS ocr_fts_ai AFTER INSERT ON ocr_entry BEGIN
+                    INSERT INTO ocr_fts(rowid, full_text, app, title)
+                    VALUES (new.id, new.full_text, new.app, new.title);
+                END
+            """)
+            exec("""
+                CREATE TRIGGER IF NOT EXISTS ocr_fts_ad AFTER DELETE ON ocr_entry BEGIN
+                    INSERT INTO ocr_fts(ocr_fts, rowid, full_text, app, title)
+                    VALUES ('delete', old.id, old.full_text, old.app, old.title);
+                END
+            """)
+            exec("""
+                CREATE TRIGGER IF NOT EXISTS ocr_fts_au AFTER UPDATE ON ocr_entry BEGIN
+                    INSERT INTO ocr_fts(ocr_fts, rowid, full_text, app, title)
+                    VALUES ('delete', old.id, old.full_text, old.app, old.title);
+                    INSERT INTO ocr_fts(rowid, full_text, app, title)
+                    VALUES (new.id, new.full_text, new.app, new.title);
+                END
+            """)
+
+            // Prepare cached statements
+            prepareInsert()
+            prepareCleanup()
+
+            // Run cleanup on open
+            cleanupSync(olderThanDays: 3)
+
+            DiagnosticLog.shared.info("OcrStore: opened \(path)")
+        }
+    }
+
+    // MARK: - Insert (batch, async)
+
+    func insert(results: [OcrWindowResult]) {
+        guard !results.isEmpty else { return }
+        queue.async { [weak self] in
+            guard let self, let db = self.db, let stmt = self.insertStmt else { return }
+
+            sqlite3_exec(db, "BEGIN TRANSACTION", nil, nil, nil)
+
+            for r in results {
+                let ts = r.timestamp.timeIntervalSince1970
+                sqlite3_bind_int(stmt, 1, Int32(r.wid))
+                self.bindText(stmt, 2, r.app)
+                self.bindText(stmt, 3, r.title)
+                sqlite3_bind_double(stmt, 4, r.frame.x)
+                sqlite3_bind_double(stmt, 5, r.frame.y)
+                sqlite3_bind_double(stmt, 6, r.frame.w)
+                sqlite3_bind_double(stmt, 7, r.frame.h)
+                self.bindText(stmt, 8, r.fullText)
+                sqlite3_bind_double(stmt, 9, ts)
+                sqlite3_step(stmt)
+                sqlite3_reset(stmt)
+                sqlite3_clear_bindings(stmt)
+            }
+
+            sqlite3_exec(db, "COMMIT", nil, nil, nil)
+        }
+    }
+
+    // MARK: - Search (FTS5, synchronous)
+
+    func search(query: String, app: String? = nil, limit: Int = 50) -> [OcrSearchResult] {
+        guard let db else { return [] }
+
+        var sql = """
+            SELECT e.id, e.wid, e.app, e.title,
+                   e.frame_x, e.frame_y, e.frame_w, e.frame_h,
+                   e.full_text, e.timestamp,
+                   snippet(ocr_fts, 0, '»', '«', '…', 32) AS snip
+            FROM ocr_fts f
+            JOIN ocr_entry e ON e.id = f.rowid
+            WHERE ocr_fts MATCH ?1
+        """
+        if app != nil { sql += " AND e.app = ?2" }
+        sql += " ORDER BY rank LIMIT ?3"
+
+        var stmt: OpaquePointer?
+        guard sqlite3_prepare_v2(db, sql, -1, &stmt, nil) == SQLITE_OK else { return [] }
+        defer { sqlite3_finalize(stmt) }
+
+        bindText(stmt!, 1, query)
+        if let app { bindText(stmt!, 2, app) }
+        sqlite3_bind_int(stmt!, 3, Int32(limit))
+
+        var results: [OcrSearchResult] = []
+        while sqlite3_step(stmt) == SQLITE_ROW {
+            results.append(rowToSearchResult(stmt!))
+        }
+        return results
+    }
+
+    // MARK: - History (per-window, synchronous)
+
+    func history(wid: UInt32, limit: Int = 50) -> [OcrSearchResult] {
+        guard let db else { return [] }
+
+        let sql = """
+            SELECT id, wid, app, title,
+                   frame_x, frame_y, frame_w, frame_h,
+                   full_text, timestamp, '' AS snip
+            FROM ocr_entry
+            WHERE wid = ?1
+            ORDER BY timestamp DESC
+            LIMIT ?2
+        """
+
+        var stmt: OpaquePointer?
+        guard sqlite3_prepare_v2(db, sql, -1, &stmt, nil) == SQLITE_OK else { return [] }
+        defer { sqlite3_finalize(stmt) }
+
+        sqlite3_bind_int(stmt!, 1, Int32(wid))
+        sqlite3_bind_int(stmt!, 2, Int32(limit))
+
+        var results: [OcrSearchResult] = []
+        while sqlite3_step(stmt) == SQLITE_ROW {
+            results.append(rowToSearchResult(stmt!))
+        }
+        return results
+    }
+
+    // MARK: - Recent (chronological, synchronous)
+
+    func recent(limit: Int = 50) -> [OcrSearchResult] {
+        guard let db else { return [] }
+
+        let sql = """
+            SELECT id, wid, app, title,
+                   frame_x, frame_y, frame_w, frame_h,
+                   full_text, timestamp, '' AS snip
+            FROM ocr_entry
+            ORDER BY timestamp DESC
+            LIMIT ?1
+        """
+
+        var stmt: OpaquePointer?
+        guard sqlite3_prepare_v2(db, sql, -1, &stmt, nil) == SQLITE_OK else { return [] }
+        defer { sqlite3_finalize(stmt) }
+
+        sqlite3_bind_int(stmt!, 1, Int32(limit))
+
+        var results: [OcrSearchResult] = []
+        while sqlite3_step(stmt) == SQLITE_ROW {
+            results.append(rowToSearchResult(stmt!))
+        }
+        return results
+    }
+
+    // MARK: - Cleanup
+
+    private func cleanupSync(olderThanDays days: Int) {
+        guard let db, let stmt = cleanupStmt else { return }
+        let cutoff = Date().timeIntervalSince1970 - Double(days * 86400)
+        sqlite3_bind_double(stmt, 1, cutoff)
+        sqlite3_step(stmt)
+        sqlite3_reset(stmt)
+        sqlite3_clear_bindings(stmt)
+
+        let deleted = sqlite3_changes(db)
+        if deleted > 0 {
+            DiagnosticLog.shared.info("OcrStore: cleaned up \(deleted) entries older than \(days) days")
+        }
+    }
+
+    // MARK: - Helpers
+
+    private func exec(_ sql: String) {
+        guard let db else { return }
+        var err: UnsafeMutablePointer<CChar>?
+        if sqlite3_exec(db, sql, nil, nil, &err) != SQLITE_OK {
+            let msg = err.map { String(cString: $0) } ?? "unknown"
+            DiagnosticLog.shared.error("OcrStore SQL error: \(msg)")
+            sqlite3_free(err)
+        }
+    }
+
+    private func bindText(_ stmt: OpaquePointer, _ index: Int32, _ value: String) {
+        sqlite3_bind_text(stmt, index, value, -1, sqliteTransient)
+    }
+
+    private func prepareInsert() {
+        let sql = """
+            INSERT INTO ocr_entry (wid, app, title, frame_x, frame_y, frame_w, frame_h, full_text, timestamp)
+            VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9)
+        """
+        sqlite3_prepare_v2(db, sql, -1, &insertStmt, nil)
+    }
+
+    private func prepareCleanup() {
+        let sql = "DELETE FROM ocr_entry WHERE timestamp < ?1"
+        sqlite3_prepare_v2(db, sql, -1, &cleanupStmt, nil)
+    }
+
+    private func columnText(_ stmt: OpaquePointer, _ index: Int32) -> String {
+        if let cStr = sqlite3_column_text(stmt, index) {
+            return String(cString: cStr)
+        }
+        return ""
+    }
+
+    private func rowToSearchResult(_ stmt: OpaquePointer) -> OcrSearchResult {
+        OcrSearchResult(
+            id: sqlite3_column_int64(stmt, 0),
+            wid: UInt32(sqlite3_column_int(stmt, 1)),
+            app: columnText(stmt, 2),
+            title: columnText(stmt, 3),
+            frame: WindowFrame(
+                x: sqlite3_column_double(stmt, 4),
+                y: sqlite3_column_double(stmt, 5),
+                w: sqlite3_column_double(stmt, 6),
+                h: sqlite3_column_double(stmt, 7)
+            ),
+            fullText: columnText(stmt, 8),
+            snippet: columnText(stmt, 10),
+            timestamp: Date(timeIntervalSince1970: sqlite3_column_double(stmt, 9))
+        )
+    }
+}