@lattices/cli 0.4.14 → 0.6.0

package/apps/mac/Sources/Core/Desktop/OcrStore.swift

@@ -1,329 +0,0 @@
-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/apps/mac/Sources/Core/Desktop/PlacementSpec.swift

@@ -1,195 +0,0 @@
-import CoreGraphics
-import Foundation
-
-struct GridPlacement: Equatable {
-    let columns: Int
-    let rows: Int
-    let column: Int
-    let row: Int
-
-    init?(columns: Int, rows: Int, column: Int, row: Int) {
-        guard columns > 0, rows > 0,
-              column >= 0, column < columns,
-              row >= 0, row < rows else { return nil }
-        self.columns = columns
-        self.rows = rows
-        self.column = column
-        self.row = row
-    }
-
-    static func parse(_ str: String) -> GridPlacement? {
-        let parts = str.split(separator: ":")
-        guard parts.count == 3, parts[0] == "grid" else { return nil }
-        let dims = parts[1].split(separator: "x")
-        let coords = parts[2].split(separator: ",")
-        guard dims.count == 2, coords.count == 2,
-              let columns = Int(dims[0]), let rows = Int(dims[1]),
-              let column = Int(coords[0]), let row = Int(coords[1]) else {
-            return nil
-        }
-        return GridPlacement(columns: columns, rows: rows, column: column, row: row)
-    }
-
-    var fractions: (CGFloat, CGFloat, CGFloat, CGFloat) {
-        let w = 1.0 / CGFloat(columns)
-        let h = 1.0 / CGFloat(rows)
-        return (CGFloat(column) * w, CGFloat(row) * h, w, h)
-    }
-
-    var wireValue: String {
-        "grid:\(columns)x\(rows):\(column),\(row)"
-    }
-}
-
-struct FractionalPlacement: Equatable {
-    let x: CGFloat
-    let y: CGFloat
-    let w: CGFloat
-    let h: CGFloat
-
-    init?(x: CGFloat, y: CGFloat, w: CGFloat, h: CGFloat) {
-        guard x >= 0, y >= 0, w > 0, h > 0,
-              x + w <= 1.0001, y + h <= 1.0001 else { return nil }
-        self.x = x
-        self.y = y
-        self.w = w
-        self.h = h
-    }
-
-    var fractions: (CGFloat, CGFloat, CGFloat, CGFloat) {
-        (x, y, w, h)
-    }
-}
-
-enum PlacementSpec: Equatable {
-    case tile(TilePosition)
-    case grid(GridPlacement)
-    case fractions(FractionalPlacement)
-
-    init?(string: String) {
-        let normalized = PlacementSpec.normalize(string)
-        if let position = TilePosition(rawValue: normalized) {
-            self = .tile(position)
-            return
-        }
-        if let alias = PlacementSpec.aliases[normalized], let position = TilePosition(rawValue: alias) {
-            self = .tile(position)
-            return
-        }
-        if let grid = GridPlacement.parse(normalized) {
-            self = .grid(grid)
-            return
-        }
-        return nil
-    }
-
-    init?(json: JSON?) {
-        guard let json else { return nil }
-
-        if let string = json.stringValue {
-            self.init(string: string)
-            return
-        }
-
-        guard case .object(let obj) = json,
-              let kind = obj["kind"]?.stringValue?.lowercased() else {
-            return nil
-        }
-
-        switch kind {
-        case "tile", "named", "position":
-            guard let value = obj["value"]?.stringValue else { return nil }
-            self.init(string: value)
-        case "grid":
-            guard let columns = obj["columns"]?.intValue,
-                  let rows = obj["rows"]?.intValue,
-                  let column = obj["column"]?.intValue,
-                  let row = obj["row"]?.intValue,
-                  let grid = GridPlacement(columns: columns, rows: rows, column: column, row: row) else {
-                return nil
-            }
-            self = .grid(grid)
-        case "fractions":
-            guard let x = obj["x"]?.numericDouble,
-                  let y = obj["y"]?.numericDouble,
-                  let w = obj["w"]?.numericDouble,
-                  let h = obj["h"]?.numericDouble,
-                  let placement = FractionalPlacement(
-                    x: CGFloat(x),
-                    y: CGFloat(y),
-                    w: CGFloat(w),
-                    h: CGFloat(h)
-                  ) else {
-                return nil
-            }
-            self = .fractions(placement)
-        default:
-            return nil
-        }
-    }
-
-    var fractions: (CGFloat, CGFloat, CGFloat, CGFloat) {
-        switch self {
-        case .tile(let position):
-            return position.rect
-        case .grid(let grid):
-            return grid.fractions
-        case .fractions(let placement):
-            return placement.fractions
-        }
-    }
-
-    var wireValue: String {
-        switch self {
-        case .tile(let position):
-            return position.rawValue
-        case .grid(let grid):
-            return grid.wireValue
-        case .fractions(let placement):
-            return "fractions:\(placement.x),\(placement.y),\(placement.w),\(placement.h)"
-        }
-    }
-
-    var jsonValue: JSON {
-        switch self {
-        case .tile(let position):
-            return .object([
-                "kind": .string("tile"),
-                "value": .string(position.rawValue),
-            ])
-        case .grid(let grid):
-            return .object([
-                "kind": .string("grid"),
-                "columns": .int(grid.columns),
-                "rows": .int(grid.rows),
-                "column": .int(grid.column),
-                "row": .int(grid.row),
-            ])
-        case .fractions(let placement):
-            return .object([
-                "kind": .string("fractions"),
-                "x": .double(Double(placement.x)),
-                "y": .double(Double(placement.y)),
-                "w": .double(Double(placement.w)),
-                "h": .double(Double(placement.h)),
-            ])
-        }
-    }
-
-    private static func normalize(_ string: String) -> String {
-        string
-            .trimmingCharacters(in: .whitespacesAndNewlines)
-            .lowercased()
-            .replacingOccurrences(of: "_", with: "-")
-            .replacingOccurrences(of: " ", with: "-")
-    }
-
-    private static let aliases: [String: String] = [
-        "upper-third": "top-third",
-        "lower-third": "bottom-third",
-        "left-quarter": "left-quarter",
-        "right-quarter": "right-quarter",
-        "top-quarter": "top-quarter",
-        "bottom-quarter": "bottom-quarter",
-    ]
-}

package/apps/mac/Sources/Core/Desktop/SessionWindowLocator.swift

@@ -1,139 +0,0 @@
-import AppKit
-import ApplicationServices
-import CoreGraphics
-
-struct LocatedWindow {
-    let wid: UInt32
-    let pid: pid_t
-}
-
-enum SessionWindowLocator {
-    static func tag(for session: String) -> String {
-        Terminal.windowTag(for: session)
-    }
-
-    static func extractSessionName(from title: String) -> String? {
-        guard let range = title.range(of: #"\[lattices:([^\]]+)\]"#, options: .regularExpression) else {
-            return nil
-        }
-        let match = String(title[range])
-        return String(match.dropFirst(10).dropLast(1))
-    }
-
-    static func matches(session: String, title: String, extractedSessionName: String? = nil) -> Bool {
-        if extractedSessionName == session {
-            return true
-        }
-        return title.contains(tag(for: session))
-    }
-
-    static func cachedWindow(forSession session: String, in windows: [UInt32: WindowEntry]) -> WindowEntry? {
-        windows.values.first { entry in
-            matches(session: session, title: entry.title, extractedSessionName: entry.latticesSession)
-        }
-    }
-
-    static func cachedWindow(forSession session: String, desktopModel: DesktopModel = .shared) -> WindowEntry? {
-        cachedWindow(forSession: session, in: desktopModel.windows)
-    }
-
-    static func findCGWindow(tag: String) -> LocatedWindow? {
-        guard let windowList = CGWindowListCopyWindowInfo([.optionAll, .excludeDesktopElements], kCGNullWindowID) as? [[String: Any]] else {
-            return nil
-        }
-
-        for info in windowList {
-            if let name = info[kCGWindowName as String] as? String,
-               name.contains(tag),
-               let wid = info[kCGWindowNumber as String] as? UInt32,
-               let pid = info[kCGWindowOwnerPID as String] as? pid_t {
-                return LocatedWindow(wid: wid, pid: pid)
-            }
-        }
-        return nil
-    }
-
-    static func findWindow(session: String, terminal: Terminal) -> LocatedWindow? {
-        findWindow(tag: tag(for: session), terminal: terminal)
-    }
-
-    static func findWindow(tag: String, terminal: Terminal) -> LocatedWindow? {
-        if let match = findCGWindow(tag: tag) {
-            return match
-        }
-
-        if let ax = findAXWindow(terminal: terminal, tag: tag),
-           let wid = matchCGWindow(pid: ax.pid, axWindow: ax.window) {
-            return LocatedWindow(wid: wid, pid: ax.pid)
-        }
-
-        return nil
-    }
-
-    static func findAXWindow(terminal: Terminal, tag: String) -> (pid: pid_t, window: AXUIElement)? {
-        let diag = DiagnosticLog.shared
-        guard let app = NSWorkspace.shared.runningApplications.first(where: {
-            $0.bundleIdentifier == terminal.bundleId
-        }) else {
-            diag.error("SessionWindowLocator.findAXWindow: \(terminal.rawValue) (\(terminal.bundleId)) not running")
-            return nil
-        }
-
-        let pid = app.processIdentifier
-        let appRef = AXUIElementCreateApplication(pid)
-        var windowsRef: CFTypeRef?
-        let err = AXUIElementCopyAttributeValue(appRef, kAXWindowsAttribute as CFString, &windowsRef)
-        guard err == .success, let windows = windowsRef as? [AXUIElement] else {
-            diag.error("SessionWindowLocator.findAXWindow: AX error \(err.rawValue) — Accessibility not granted?")
-            return nil
-        }
-
-        diag.info("SessionWindowLocator.findAXWindow: \(windows.count) windows for \(terminal.rawValue), searching for \(tag)")
-        for win in windows {
-            var titleRef: CFTypeRef?
-            AXUIElementCopyAttributeValue(win, kAXTitleAttribute as CFString, &titleRef)
-            let title = titleRef as? String ?? "<no title>"
-            if title.contains(tag) {
-                diag.success("SessionWindowLocator.findAXWindow: matched \"\(title)\"")
-                return (pid, win)
-            } else {
-                diag.info("  skip: \"\(title)\"")
-            }
-        }
-
-        diag.warn("SessionWindowLocator.findAXWindow: no window matched tag \(tag)")
-        return nil
-    }
-
-    static func matchCGWindow(pid: pid_t, axWindow: AXUIElement) -> UInt32? {
-        var posRef: CFTypeRef?
-        var sizeRef: CFTypeRef?
-        AXUIElementCopyAttributeValue(axWindow, kAXPositionAttribute as CFString, &posRef)
-        AXUIElementCopyAttributeValue(axWindow, kAXSizeAttribute as CFString, &sizeRef)
-        guard let pv = posRef, let sv = sizeRef else { return nil }
-
-        var pos = CGPoint.zero
-        var size = CGSize.zero
-        AXValueGetValue(pv as! AXValue, .cgPoint, &pos)
-        AXValueGetValue(sv as! AXValue, .cgSize, &size)
-
-        guard let windowList = CGWindowListCopyWindowInfo([.optionAll, .excludeDesktopElements], kCGNullWindowID) as? [[String: Any]] else {
-            return nil
-        }
-
-        for info in windowList {
-            guard let wPid = info[kCGWindowOwnerPID as String] as? pid_t,
-                  wPid == pid,
-                  let wid = info[kCGWindowNumber as String] as? UInt32,
-                  let boundsDict = info[kCGWindowBounds as String] as? NSDictionary else { continue }
-            var rect = CGRect.zero
-            if CGRectMakeWithDictionaryRepresentation(boundsDict, &rect) {
-                if abs(rect.origin.x - pos.x) < 2 && abs(rect.origin.y - pos.y) < 2 &&
-                    abs(rect.width - size.width) < 2 && abs(rect.height - size.height) < 2 {
-                    return wid
-                }
-            }
-        }
-        return nil
-    }
-}