@lattices/cli 0.4.14 → 0.5.0

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

@@ -1,111 +0,0 @@
-import AppKit
-
-// Private API: get CGWindowID from an AXUIElement (already declared in WindowTiler.swift)
-// We reuse the same _AXUIElementGetWindow binding.
-
-struct AXTextResult {
-    let wid: UInt32
-    let texts: [String]
-    let fullText: String
-}
-
-final class AccessibilityTextExtractor {
-    static let timeoutSeconds: TimeInterval = 0.2
-    static let maxDepth: Int = 4
-    static let maxChildrenPerNode: Int = 30
-
-    /// Extract text from a window's AX element tree.
-    /// Returns nil if AX fails or yields fewer than `minChars` characters.
-    func extract(pid: Int32, wid: UInt32, minChars: Int = 12) -> AXTextResult? {
-        let appRef = AXUIElementCreateApplication(pid)
-
-        // Find the AXUIElement matching this wid
-        var windowsRef: CFTypeRef?
-        let err = AXUIElementCopyAttributeValue(appRef, kAXWindowsAttribute as CFString, &windowsRef)
-        guard err == .success, let axWindows = windowsRef as? [AXUIElement] else { return nil }
-
-        var targetWindow: AXUIElement?
-        for axWin in axWindows {
-            var winID: CGWindowID = 0
-            if _AXUIElementGetWindow(axWin, &winID) == .success, winID == CGWindowID(wid) {
-                targetWindow = axWin
-                break
-            }
-        }
-
-        guard let window = targetWindow else { return nil }
-
-        let deadline = Date().addingTimeInterval(Self.timeoutSeconds)
-        var collected: [String] = []
-
-        walkChildren(element: window, depth: 0, deadline: deadline, collected: &collected)
-
-        let fullText = collected.joined(separator: "\n")
-        guard fullText.count >= minChars else { return nil }
-
-        return AXTextResult(wid: wid, texts: collected, fullText: fullText)
-    }
-
-    // MARK: - Tree Walker
-
-    private func walkChildren(
-        element: AXUIElement,
-        depth: Int,
-        deadline: Date,
-        collected: inout [String]
-    ) {
-        guard depth < Self.maxDepth, Date() < deadline else { return }
-
-        // Extract text attributes from this element
-        extractText(from: element, into: &collected)
-
-        // Get children — prefer visible children, fall back to all children
-        var childrenRef: CFTypeRef?
-        var gotChildren = false
-
-        let visErr = AXUIElementCopyAttributeValue(element, kAXVisibleChildrenAttribute as CFString, &childrenRef)
-        if visErr == .success, let children = childrenRef as? [AXUIElement], !children.isEmpty {
-            gotChildren = true
-            let capped = children.prefix(Self.maxChildrenPerNode)
-            for child in capped {
-                guard Date() < deadline else { return }
-                walkChildren(element: child, depth: depth + 1, deadline: deadline, collected: &collected)
-            }
-        }
-
-        if !gotChildren {
-            childrenRef = nil
-            let childErr = AXUIElementCopyAttributeValue(element, kAXChildrenAttribute as CFString, &childrenRef)
-            if childErr == .success, let children = childrenRef as? [AXUIElement] {
-                let capped = children.prefix(Self.maxChildrenPerNode)
-                for child in capped {
-                    guard Date() < deadline else { return }
-                    walkChildren(element: child, depth: depth + 1, deadline: deadline, collected: &collected)
-                }
-            }
-        }
-    }
-
-    private func extractText(from element: AXUIElement, into collected: inout [String]) {
-        // kAXValueAttribute — text field contents, labels, etc.
-        var valueRef: CFTypeRef?
-        if AXUIElementCopyAttributeValue(element, kAXValueAttribute as CFString, &valueRef) == .success,
-           let str = valueRef as? String, !str.isEmpty, str.count > 1 {
-            collected.append(str)
-        }
-
-        // kAXTitleAttribute — window/button titles
-        var titleRef: CFTypeRef?
-        if AXUIElementCopyAttributeValue(element, kAXTitleAttribute as CFString, &titleRef) == .success,
-           let str = titleRef as? String, !str.isEmpty, str.count > 1 {
-            collected.append(str)
-        }
-
-        // kAXDescriptionAttribute — accessible descriptions
-        var descRef: CFTypeRef?
-        if AXUIElementCopyAttributeValue(element, kAXDescriptionAttribute as CFString, &descRef) == .success,
-           let str = descRef as? String, !str.isEmpty, str.count > 1 {
-            collected.append(str)
-        }
-    }
-}

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

@@ -1,106 +0,0 @@
-import Foundation
-
-enum AppType: String, CaseIterable {
-    case terminal
-    case editor
-    case browser
-    case chat
-    case media
-    case design
-    case system
-    case other
-
-    var label: String { rawValue }
-}
-
-enum AppGrouping {
-    case type(AppType)
-    case exactApp(String)
-
-    var label: String {
-        switch self {
-        case .type(let type):
-            return type.label
-        case .exactApp(let appName):
-            return appName
-        }
-    }
-}
-
-enum AppTypeClassifier {
-    private static let nameMap: [String: AppType] = [
-        // Terminals
-        "iTerm2": .terminal, "Terminal": .terminal, "Alacritty": .terminal,
-        "kitty": .terminal, "Warp": .terminal, "Hyper": .terminal,
-        "WezTerm": .terminal, "Rio": .terminal, "Ghostty": .terminal,
-
-        // Editors / IDEs
-        "Xcode": .editor, "Code": .editor, "Visual Studio Code": .editor,
-        "Cursor": .editor, "Sublime Text": .editor, "TextEdit": .editor,
-        "Nova": .editor, "BBEdit": .editor, "Zed": .editor,
-        "IntelliJ IDEA": .editor, "WebStorm": .editor, "PyCharm": .editor,
-        "CLion": .editor, "GoLand": .editor, "RustRover": .editor,
-        "Android Studio": .editor, "Fleet": .editor, "Neovide": .editor,
-
-        // Browsers
-        "Safari": .browser, "Google Chrome": .browser, "Firefox": .browser,
-        "Arc": .browser, "Brave Browser": .browser, "Microsoft Edge": .browser,
-        "Orion": .browser, "Vivaldi": .browser, "Opera": .browser,
-        "Chrome": .browser, "Zen Browser": .browser,
-
-        // Chat / Communication
-        "Slack": .chat, "Discord": .chat, "Messages": .chat,
-        "Telegram": .chat, "WhatsApp": .chat, "Signal": .chat,
-        "Teams": .chat, "Microsoft Teams": .chat, "Zoom": .chat,
-        "FaceTime": .chat, "Skype": .chat,
-
-        // Media
-        "Spotify": .media, "Music": .media, "QuickTime Player": .media,
-        "VLC": .media, "IINA": .media, "Podcasts": .media,
-        "Photos": .media, "Preview": .media, "mpv": .media,
-
-        // Design
-        "Figma": .design, "Sketch": .design, "Pixelmator Pro": .design,
-        "Affinity Designer 2": .design, "Affinity Photo 2": .design,
-        "Adobe Photoshop": .design, "Adobe Illustrator": .design,
-        "Blender": .design, "OmniGraffle": .design,
-
-        // System
-        "Finder": .system, "System Preferences": .system, "System Settings": .system,
-        "Activity Monitor": .system, "Console": .system, "Disk Utility": .system,
-        "Keychain Access": .system,
-    ]
-
-    static func classify(_ appName: String) -> AppType {
-        if let exact = nameMap[appName] { return exact }
-        // Substring fallback
-        let lower = appName.lowercased()
-        if lower.contains("terminal") || lower.contains("term") { return .terminal }
-        if lower.contains("code") || lower.contains("studio") || lower.contains("edit") { return .editor }
-        if lower.contains("chrome") || lower.contains("firefox") || lower.contains("safari") || lower.contains("browser") { return .browser }
-        if lower.contains("slack") || lower.contains("discord") || lower.contains("chat") || lower.contains("teams") { return .chat }
-        return .other
-    }
-
-    static func grouping(for appName: String) -> AppGrouping {
-        switch classify(appName) {
-        case .system, .other:
-            return .exactApp(appName)
-        case let type:
-            return .type(type)
-        }
-    }
-
-    static func matches(_ appName: String, grouping: AppGrouping) -> Bool {
-        switch grouping {
-        case .type(let type):
-            return classify(appName) == type
-        case .exactApp(let exactApp):
-            return appName.localizedCaseInsensitiveCompare(exactApp) == .orderedSame
-        }
-    }
-
-    static func matches(_ appName: String, type: AppType) -> Bool {
-        classify(appName) == type
-    }
-}

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

@@ -1,331 +0,0 @@
-import AppKit
-import ApplicationServices
-import CoreGraphics
-
-final class DesktopModel: ObservableObject {
-    static let shared = DesktopModel()
-
-    /// System helper processes that should never appear in search results or window lists.
-    /// These are XPC services, agents, and background helpers — not user-facing apps.
-    private static let systemHelperProcesses: Set<String> = [
-        // Apple system helpers
-        "CredentialsProviderExtensionHost",
-        "AuthenticationServicesAgent",
-        "SafariPasswordExtension",
-        "com.apple.WebKit.WebAuthn",
-        "SharedWebCredentialRunner",
-        "ViewBridgeAuxiliary",
-        "universalaccessd",
-        "CoreServicesUIAgent",
-        "UserNotificationCenter",
-        "AutoFillPanelService",
-        "AutoFill",
-        "CoreLocationAgent",
-        "SecurityAgent",
-        "coreautha",
-        "coreauth",
-        "talagent",
-        "CommCenter",
-        "AXVisualSupportAgent",
-        "SystemUIServer",
-        "Dock",
-        "Window Server",
-        "WindowManager",
-        "NotificationCenter",
-        "ControlCenter",
-        "Spotlight",
-        "Keychain Access",
-        "loginwindow",
-        "ScreenSaverEngine",
-        "SoftwareUpdateNotificationManager",
-        "WiFiAgent",
-        "pboard",
-        "storeuid",
-        // Third-party helpers
-        "CursorUIViewService",
-        "Codex Computer Use",
-        "Electron Helper",
-        "Google Chrome Helper",
-    ]
-
-    /// Suffixes that indicate a helper/service process, not a user-facing app
-    private static let helperSuffixes = ["Service", "Agent", "Helper", "Extension", "Daemon", "XPCService"]
-
-    /// Real apps that happen to match helper suffixes — don't filter these
-    private static let knownRealApps: Set<String> = [
-        "Finder",
-        "Activity Monitor",
-    ]
-
-    @Published private(set) var windows: [UInt32: WindowEntry] = [:]
-    @Published private(set) var interactionDates: [UInt32: Date] = [:]
-    /// In-memory layer tags: wid → layer id (e.g. "lattices", "vox", "hudson")
-    private(set) var windowLayerTags: [UInt32: String] = [:]
-    private var timer: Timer?
-    private var lastFrontmostWid: UInt32?
-
-    func start(interval: TimeInterval = 1.5) {
-        guard timer == nil else { return }
-        DiagnosticLog.shared.info("DesktopModel: starting (interval=\(interval)s)")
-        poll()
-        timer = Timer.scheduledTimer(withTimeInterval: interval, repeats: true) { [weak self] _ in
-            self?.poll()
-        }
-    }
-
-    func stop() {
-        timer?.invalidate()
-        timer = nil
-    }
-
-    func allWindows() -> [WindowEntry] {
-        Array(windows.values).sorted { $0.zIndex < $1.zIndex }
-    }
-
-    func frontmostWindow() -> WindowEntry? {
-        windows.values.min { $0.zIndex < $1.zIndex }
-    }
-
-    func lastInteractionDate(for wid: UInt32) -> Date? {
-        interactionDates[wid]
-    }
-
-    func markInteraction(wid: UInt32, at date: Date = Date()) {
-        DispatchQueue.main.async {
-            self.interactionDates[wid] = date
-        }
-    }
-
-    func markInteraction(wids: [UInt32], at date: Date = Date()) {
-        guard !wids.isEmpty else { return }
-        let unique = Set(wids)
-        DispatchQueue.main.async {
-            for wid in unique {
-                self.interactionDates[wid] = date
-            }
-        }
-    }
-
-    func windowForSession(_ session: String) -> WindowEntry? {
-        SessionWindowLocator.cachedWindow(forSession: session, in: windows)
-    }
-
-    /// Assign a layer tag to a window (in-memory only)
-    func assignLayer(wid: UInt32, layerId: String) {
-        windowLayerTags[wid] = layerId
-    }
-
-    /// Remove layer tag from a window
-    func removeLayerTag(wid: UInt32) {
-        windowLayerTags.removeValue(forKey: wid)
-    }
-
-    /// Clear all layer tags
-    func clearLayerTags() {
-        windowLayerTags.removeAll()
-    }
-
-    /// Find a window by app name and optional title substring (case-insensitive)
-    func windowForApp(app: String, title: String?) -> WindowEntry? {
-        let matches = windows.values.filter {
-            $0.app.localizedCaseInsensitiveContains(app)
-        }
-        if let title {
-            return matches.first { $0.title.localizedCaseInsensitiveContains(title) }
-        }
-        return matches.first
-    }
-
-    // MARK: - Polling
-
-    private var lastPollTime: Date = .distantPast
-    private static let minPollInterval: TimeInterval = 1.0
-
-    /// Poll only if stale. Call `forcePoll()` to bypass the freshness check.
-    func poll() {
-        let now = Date()
-        guard now.timeIntervalSince(lastPollTime) >= Self.minPollInterval else { return }
-        lastPollTime = now
-        performPoll()
-    }
-
-    /// Force a poll regardless of freshness — use sparingly.
-    func forcePoll() {
-        lastPollTime = Date()
-        performPoll()
-    }
-
-    private func performPoll() {
-        guard let list = CGWindowListCopyWindowInfo(
-            [.optionAll, .excludeDesktopElements],
-            kCGNullWindowID
-        ) as? [[String: Any]] else { return }
-
-        var fresh: [UInt32: WindowEntry] = [:]
-        var zCounter = 0
-
-        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 tiny windows (menu extras, status items)
-            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
-            let isOnScreen = info[kCGWindowIsOnscreen as String] as? Bool ?? false
-
-            // Skip non-standard layers (menus, overlays)
-            guard layer == 0 else { continue }
-
-            // Skip system helper processes (autofill, credential providers, etc.)
-            if Self.systemHelperProcesses.contains(ownerName) { continue }
-
-            // Skip processes whose name ends with common helper suffixes
-            // (e.g. "CursorUIViewService", "AutoFillPanelService", "SecurityAgent")
-            // but not known real apps that happen to have these words
-            let isHelperByName = Self.helperSuffixes.contains(where: { ownerName.hasSuffix($0) })
-                && !Self.knownRealApps.contains(ownerName)
-            if isHelperByName { continue }
-
-            // Skip windows with no title from processes containing "com.apple."
-            if ownerName.hasPrefix("com.apple.") && title.isEmpty { continue }
-
-            let frame = WindowFrame(
-                x: Double(rect.origin.x),
-                y: Double(rect.origin.y),
-                w: Double(rect.width),
-                h: Double(rect.height)
-            )
-
-            let spaceIds = WindowTiler.getSpacesForWindow(wid)
-
-            let latticesSession = SessionWindowLocator.extractSessionName(from: title)
-
-            var entry = WindowEntry(
-                wid: wid,
-                app: ownerName,
-                pid: pid,
-                title: title,
-                frame: frame,
-                spaceIds: spaceIds,
-                isOnScreen: isOnScreen,
-                latticesSession: latticesSession
-            )
-            entry.zIndex = zCounter
-            zCounter += 1
-            fresh[wid] = entry
-        }
-
-        // AX reconciliation: check which CG windows actually exist in Accessibility
-        reconcileWithAX(&fresh)
-
-        // Diff
-        let oldKeys = Set(windows.keys)
-        let newKeys = Set(fresh.keys)
-        let added = Array(newKeys.subtracting(oldKeys))
-        let removed = Array(oldKeys.subtracting(newKeys))
-
-        let changed = added.count > 0 || removed.count > 0 || windowsContentChanged(old: windows, new: fresh)
-        let frontmostWid = fresh.values.min(by: { $0.zIndex < $1.zIndex })?.wid
-        let markFrontmost = frontmostWid != nil && frontmostWid != lastFrontmostWid
-        let interactionTime = Date()
-
-        DispatchQueue.main.async {
-            var interactions = self.interactionDates.filter { fresh[$0.key] != nil }
-            if markFrontmost, let frontmostWid {
-                interactions[frontmostWid] = interactionTime
-            }
-            // Only publish if something actually changed — avoids unnecessary SwiftUI re-renders
-            if changed || markFrontmost {
-                self.windows = fresh
-                self.interactionDates = interactions
-            }
-            self.lastFrontmostWid = frontmostWid
-        }
-
-        if changed {
-            EventBus.shared.post(.windowsChanged(
-                windows: Array(fresh.values),
-                added: added,
-                removed: removed
-            ))
-        }
-    }
-
-    private func reconcileWithAX(_ fresh: inout [UInt32: WindowEntry]) {
-        // Get currently active Space IDs — AX only returns windows on these
-        let currentSpaceIds = Set(WindowTiler.getDisplaySpaces().map(\.currentSpaceId))
-        guard !currentSpaceIds.isEmpty else { return }
-
-        // Group CG windows by PID — only titled windows on current Spaces
-        var byPid: [Int32: [UInt32]] = [:]
-        for (wid, entry) in fresh where !entry.title.isEmpty {
-            let onCurrentSpace = entry.spaceIds.contains { currentSpaceIds.contains($0) }
-            if onCurrentSpace {
-                byPid[entry.pid, default: []].append(wid)
-            }
-        }
-
-        for (pid, wids) in byPid {
-            let axApp = AXUIElementCreateApplication(pid)
-
-            // Set a timeout so unresponsive apps (video calls, etc.) don't block the poll
-            AXUIElementSetMessagingTimeout(axApp, 0.3)
-
-            var axWindowsRef: CFTypeRef?
-            guard AXUIElementCopyAttributeValue(axApp, kAXWindowsAttribute as CFString, &axWindowsRef) == .success,
-                  let axWindows = axWindowsRef as? [AXUIElement] else { continue }
-
-            // Collect AX window titles
-            var axTitles: [String] = []
-            for axWin in axWindows {
-                var titleRef: CFTypeRef?
-                AXUIElementCopyAttributeValue(axWin, kAXTitleAttribute as CFString, &titleRef)
-                if let title = titleRef as? String, !title.isEmpty {
-                    axTitles.append(title)
-                }
-            }
-
-            // Mark CG windows that have no matching AX title.
-            // AX titles often have suffixes like " - Google Chrome - Profile"
-            // so check if any AX title starts with the CG title (stripped of emoji).
-            for wid in wids {
-                guard let entry = fresh[wid], !entry.title.isEmpty else { continue }
-                let cgClean = stripForMatch(entry.title)
-                let matched = axTitles.contains { axTitle in
-                    let axClean = stripForMatch(axTitle)
-                    return axClean.hasPrefix(cgClean) || axClean.contains(cgClean) || cgClean.hasPrefix(axClean)
-                }
-                if !matched {
-                    fresh[wid]?.axVerified = false
-                }
-            }
-        }
-    }
-
-    private func stripForMatch(_ text: String) -> String {
-        // Remove emoji and non-ASCII symbols, lowercase, collapse whitespace
-        let scalar = text.unicodeScalars.filter { scalar in
-            scalar.isASCII || CharacterSet.letters.contains(scalar)
-        }
-        return String(scalar).lowercased()
-            .split(separator: " ").joined(separator: " ")
-    }
-
-    private func windowsContentChanged(old: [UInt32: WindowEntry], new: [UInt32: WindowEntry]) -> Bool {
-        // Quick check: if titles or frames changed for any existing window
-        for (wid, newEntry) in new {
-            guard let oldEntry = old[wid] else { continue }
-            if oldEntry.title != newEntry.title || oldEntry.frame != newEntry.frame {
-                return true
-            }
-        }
-        return false
-    }
-}

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

@@ -1,73 +0,0 @@
-import Foundation
-
-struct WindowEntry: Codable, Identifiable {
-    let wid: UInt32
-    let app: String
-    let pid: Int32
-    let title: String
-    let frame: WindowFrame
-    let spaceIds: [Int]
-    let isOnScreen: Bool
-    let latticesSession: String?
-    var axVerified: Bool = true
-    var zIndex: Int = 0 // 0 = frontmost, from CGWindowList order
-
-    var id: UInt32 { wid }
-}
-
-struct WindowFrame: Codable, Equatable {
-    let x: Double
-    let y: Double
-    let w: Double
-    let h: Double
-}
-
-// MARK: - Desktop Inventory Snapshot
-
-struct DesktopInventorySnapshot {
-    let displays: [DisplayInfo]
-    let timestamp: Date
-
-    struct DisplayInfo: Identifiable {
-        let id: String           // display UUID or index
-        let name: String         // e.g. "Built-in Retina", "LG UltraFine"
-        let resolution: (w: Int, h: Int)
-        let visibleFrame: (w: Int, h: Int)
-        let isMain: Bool
-        let spaceCount: Int
-        let currentSpaceIndex: Int
-        let spaces: [SpaceGroup]
-    }
-
-    struct SpaceGroup: Identifiable {
-        let id: Int              // CGS space ID
-        let index: Int           // 1-based index within display
-        let isCurrent: Bool
-        let apps: [AppGroup]
-    }
-
-    struct AppGroup: Identifiable {
-        let id: String           // unique key (spaceId-appName)
-        let appName: String
-        let windows: [InventoryWindowInfo]
-    }
-
-    struct InventoryWindowInfo: Identifiable {
-        let id: UInt32           // CGWindowID
-        let pid: Int32           // owner PID for AX operations
-        let title: String
-        let frame: WindowFrame
-        let tilePosition: TilePosition?
-        let isLattices: Bool
-        let latticesSession: String?
-        let spaceIndex: Int?     // 1-based space index within display
-        let isOnScreen: Bool     // on current space
-        var inventoryPath: InventoryPath?
-        var appName: String?     // owner app name for filtering
-    }
-
-    /// Flat list of all windows across all displays/spaces/apps
-    var allWindows: [InventoryWindowInfo] {
-        displays.flatMap { $0.spaces.flatMap { $0.apps.flatMap { $0.windows } } }
-    }
-}

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

@@ -1,35 +0,0 @@
-import Foundation
-
-class InventoryManager: ObservableObject {
-    static let shared = InventoryManager()
-
-    @Published var orphans: [TmuxSession] = []
-    @Published var allSessions: [TmuxSession] = []
-
-    func refresh() {
-        // Always query fresh — this is called on explicit user refresh
-        let sessions = TmuxQuery.listSessions()
-
-        // Build set of managed session names
-        var managed = Set<String>()
-
-        // From scanned projects
-        for project in ProjectScanner.shared.projects {
-            managed.insert(project.sessionName)
-        }
-
-        // From workspace tab groups
-        if let groups = WorkspaceManager.shared.config?.groups {
-            for group in groups {
-                for tab in group.tabs {
-                    managed.insert(WorkspaceManager.sessionName(for: tab.path))
-                }
-            }
-        }
-
-        DispatchQueue.main.async {
-            self.allSessions = sessions
-            self.orphans = sessions.filter { !managed.contains($0.name) }
-        }
-    }
-}