@lattices/cli 0.3.0

package/app/Sources/OcrStore.swift

@@ -0,0 +1,329 @@
+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
+    let source: TextSource
+}
+
+// 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
+            """)
+
+            // Migration: add source column if not present
+            migrateAddSourceColumn()
+
+            // 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)
+                self.bindText(stmt, 10, r.source.rawValue)
+                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,
+                   COALESCE(e.source, 'ocr') AS source
+            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,
+                   COALESCE(source, 'ocr') AS source
+            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,
+                   COALESCE(source, 'ocr') AS source
+            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, source)
+            VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10)
+        """
+        sqlite3_prepare_v2(db, sql, -1, &insertStmt, nil)
+    }
+
+    private func migrateAddSourceColumn() {
+        // Check if source column exists
+        var tableInfoStmt: OpaquePointer?
+        let sql = "PRAGMA table_info(ocr_entry)"
+        guard sqlite3_prepare_v2(db, sql, -1, &tableInfoStmt, nil) == SQLITE_OK else { return }
+        defer { sqlite3_finalize(tableInfoStmt) }
+
+        var hasSource = false
+        while sqlite3_step(tableInfoStmt) == SQLITE_ROW {
+            if let name = sqlite3_column_text(tableInfoStmt, 1) {
+                if String(cString: name) == "source" {
+                    hasSource = true
+                    break
+                }
+            }
+        }
+
+        if !hasSource {
+            exec("ALTER TABLE ocr_entry ADD COLUMN source TEXT DEFAULT 'ocr'")
+            DiagnosticLog.shared.info("OcrStore: migrated — added source column")
+        }
+    }
+
+    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 {
+        let sourceStr = columnText(stmt, 11)
+        let source = TextSource(rawValue: sourceStr) ?? .ocr
+        return 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)),
+            source: source
+        )
+    }
+}

package/app/Sources/OmniSearchState.swift

@@ -0,0 +1,283 @@
+import AppKit
+import Combine
+import Foundation
+
+// MARK: - Result Types
+
+enum OmniResultKind: String {
+    case window
+    case project
+    case session
+    case process
+    case ocrContent
+}
+
+struct OmniResult: Identifiable {
+    let id = UUID()
+    let kind: OmniResultKind
+    let title: String
+    let subtitle: String
+    let icon: String
+    let score: Int           // higher = better match
+    let action: () -> Void
+
+    /// Group label for display
+    var groupLabel: String {
+        switch kind {
+        case .window:     return "Windows"
+        case .project:    return "Projects"
+        case .session:    return "Sessions"
+        case .process:    return "Processes"
+        case .ocrContent: return "Screen Text"
+        }
+    }
+}
+
+// MARK: - Activity Summary
+
+struct ActivitySummary {
+    struct AppWindowCount: Identifiable {
+        let id: String
+        let appName: String
+        let count: Int
+    }
+
+    struct SessionInfo: Identifiable {
+        let id: String
+        let name: String
+        let paneCount: Int
+        let attached: Bool
+    }
+
+    let windowsByApp: [AppWindowCount]
+    let totalWindows: Int
+    let sessions: [SessionInfo]
+    let interestingProcesses: [ProcessEntry]
+    let lastOcrScan: Date?
+    let ocrWindowCount: Int
+}
+
+// MARK: - State
+
+final class OmniSearchState: ObservableObject {
+    @Published var query: String = ""
+    @Published var results: [OmniResult] = []
+    @Published var selectedIndex: Int = 0
+    @Published var activitySummary: ActivitySummary?
+
+    private var cancellables = Set<AnyCancellable>()
+    private var debounceTimer: AnyCancellable?
+
+    init() {
+        // Debounce search by 150ms
+        debounceTimer = $query
+            .debounce(for: .milliseconds(150), scheduler: RunLoop.main)
+            .sink { [weak self] q in
+                if q.isEmpty {
+                    self?.results = []
+                    self?.refreshSummary()
+                } else {
+                    self?.search(q)
+                }
+            }
+
+        refreshSummary()
+    }
+
+    // MARK: - Search
+
+    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
+                all.append(OmniResult(
+                    kind: .window,
+                    title: win.app,
+                    subtitle: win.title.isEmpty ? "Window \(win.wid)" : win.title,
+                    icon: "macwindow",
+                    score: score
+                ) {
+                    WindowTiler.focusWindow(wid: wid, pid: pid)
+                })
+            }
+        }
+
+        // Projects
+        let scanner = ProjectScanner.shared
+        for project in scanner.projects {
+            let score = scoreMatch(q, against: [project.name, project.path])
+            if score > 0 {
+                let proj = project
+                all.append(OmniResult(
+                    kind: .project,
+                    title: project.name,
+                    subtitle: project.path,
+                    icon: "folder",
+                    score: score
+                ) {
+                    SessionManager.launch(project: proj)
+                })
+            }
+        }
+
+        // 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
+    }
+
+    private func scoreOcr(_ query: String, fullText: String) -> Int {
+        let lower = fullText.lowercased()
+        if lower.contains(query) { return 40 }
+        return 0
+    }
+
+    // MARK: - Navigation
+
+    func moveSelection(_ delta: Int) {
+        guard !results.isEmpty else { return }
+        selectedIndex = max(0, min(results.count - 1, selectedIndex + delta))
+    }
+
+    func activateSelected() {
+        guard selectedIndex >= 0, selectedIndex < results.count else { return }
+        results[selectedIndex].action()
+    }
+
+    // MARK: - Activity Summary
+
+    func refreshSummary() {
+        let desktop = DesktopModel.shared
+        let windows = desktop.allWindows()
+
+        // Group by app
+        var appCounts: [String: Int] = [:]
+        for win in windows {
+            appCounts[win.app, default: 0] += 1
+        }
+        let windowsByApp = appCounts
+            .sorted { $0.value > $1.value }
+            .map { ActivitySummary.AppWindowCount(id: $0.key, appName: $0.key, count: $0.value) }
+
+        // Sessions
+        let sessions = TmuxModel.shared.sessions.map {
+            ActivitySummary.SessionInfo(
+                id: $0.id,
+                name: $0.name,
+                paneCount: $0.panes.count,
+                attached: $0.attached
+            )
+        }
+
+        // Processes
+        let procs = ProcessModel.shared.interesting
+
+        // OCR info
+        let ocrResults = OcrModel.shared.results
+        let lastScan: Date? = ocrResults.values.map(\.timestamp).max()
+
+        activitySummary = ActivitySummary(
+            windowsByApp: windowsByApp,
+            totalWindows: windows.count,
+            sessions: sessions,
+            interestingProcesses: procs,
+            lastOcrScan: lastScan,
+            ocrWindowCount: ocrResults.count
+        )
+    }
+
+    /// Grouped results for display
+    var groupedResults: [(String, [OmniResult])] {
+        let groups = Dictionary(grouping: results) { $0.groupLabel }
+        let order: [String] = ["Windows", "Projects", "Sessions", "Processes", "Screen Text"]
+        return order.compactMap { key in
+            guard let items = groups[key], !items.isEmpty else { return nil }
+            return (key, items)
+        }
+    }
+}