@lattices/cli 0.3.0

package/app/Sources/PaletteCommand.swift

@@ -0,0 +1,419 @@
+import AppKit
+import Foundation
+
+struct PaletteCommand: Identifiable {
+    let id: String
+    let title: String
+    let subtitle: String
+    let icon: String
+    let category: Category
+    let badge: String?
+    let action: () -> Void
+
+    enum Category: String, CaseIterable {
+        case project = "Projects"
+        case window  = "Window"
+        case app     = "App"
+
+        var icon: String {
+            switch self {
+            case .project: return "terminal"
+            case .window:  return "macwindow"
+            case .app:     return "gearshape"
+            }
+        }
+    }
+
+    /// Fuzzy match score — higher is better, 0 means no match
+    func matchScore(query: String) -> Int {
+        let q = query.lowercased()
+        let t = title.lowercased()
+        let s = subtitle.lowercased()
+
+        // Exact prefix match on title — best
+        if t.hasPrefix(q) { return 100 }
+        // Word-boundary prefix (e.g. "set" matches "Open Settings")
+        let words = t.split(separator: " ").map(String.init)
+        if words.contains(where: { $0.hasPrefix(q) }) { return 80 }
+        // Contains in title
+        if t.contains(q) { return 60 }
+        // Subtitle prefix
+        if s.hasPrefix(q) { return 50 }
+        // Subtitle contains
+        if s.contains(q) { return 40 }
+        // Subsequence match on title
+        if isSubsequence(q, of: t) { return 20 }
+        return 0
+    }
+
+    private func isSubsequence(_ needle: String, of haystack: String) -> Bool {
+        var it = haystack.makeIterator()
+        for ch in needle {
+            while let next = it.next() {
+                if next == ch { break }
+            }
+            // If iterator is exhausted before matching all chars, not a subsequence
+            // (handled by the while loop returning nil)
+        }
+        // Verify: re-check properly
+        var hi = haystack.startIndex
+        for ch in needle {
+            guard let found = haystack[hi...].firstIndex(of: ch) else { return false }
+            hi = haystack.index(after: found)
+        }
+        return true
+    }
+}
+
+// MARK: - Command Builder
+
+enum CommandBuilder {
+    static func build(scanner: ProjectScanner) -> [PaletteCommand] {
+        var projectCmds: [PaletteCommand] = []
+        var windowCmds: [PaletteCommand] = []
+        let terminal = Preferences.shared.terminal
+
+        for project in scanner.projects {
+            if project.isRunning {
+                // Project actions
+                projectCmds.append(PaletteCommand(
+                    id: "attach-\(project.id)",
+                    title: "Attach \(project.name)",
+                    subtitle: "Open terminal to running session",
+                    icon: "play.fill",
+                    category: .project,
+                    badge: "running",
+                    action: { SessionManager.launch(project: project) }
+                ))
+                // Window actions
+                windowCmds.append(PaletteCommand(
+                    id: "goto-\(project.id)",
+                    title: "Go to \(project.name)",
+                    subtitle: "Focus the terminal window",
+                    icon: "macwindow",
+                    category: .window,
+                    badge: nil,
+                    action: {
+                        WindowTiler.navigateToWindow(
+                            session: project.sessionName,
+                            terminal: terminal
+                        )
+                    }
+                ))
+                windowCmds.append(PaletteCommand(
+                    id: "tile-left-\(project.id)",
+                    title: "Tile \(project.name) Left",
+                    subtitle: "Snap window to left half",
+                    icon: "rectangle.lefthalf.filled",
+                    category: .window,
+                    badge: nil,
+                    action: {
+                        WindowTiler.tile(session: project.sessionName, terminal: terminal, to: .left)
+                    }
+                ))
+                windowCmds.append(PaletteCommand(
+                    id: "tile-right-\(project.id)",
+                    title: "Tile \(project.name) Right",
+                    subtitle: "Snap window to right half",
+                    icon: "rectangle.righthalf.filled",
+                    category: .window,
+                    badge: nil,
+                    action: {
+                        WindowTiler.tile(session: project.sessionName, terminal: terminal, to: .right)
+                    }
+                ))
+                windowCmds.append(PaletteCommand(
+                    id: "tile-max-\(project.id)",
+                    title: "Maximize \(project.name)",
+                    subtitle: "Expand window to fill screen",
+                    icon: "rectangle.fill",
+                    category: .window,
+                    badge: nil,
+                    action: {
+                        WindowTiler.tile(session: project.sessionName, terminal: terminal, to: .maximize)
+                    }
+                ))
+                windowCmds.append(PaletteCommand(
+                    id: "detach-\(project.id)",
+                    title: "Detach \(project.name)",
+                    subtitle: "Disconnect clients, keep session alive",
+                    icon: "eject.fill",
+                    category: .window,
+                    badge: nil,
+                    action: { SessionManager.detach(project: project) }
+                ))
+                windowCmds.append(PaletteCommand(
+                    id: "kill-\(project.id)",
+                    title: "Kill \(project.name)",
+                    subtitle: "Terminate the tmux session",
+                    icon: "xmark.circle.fill",
+                    category: .window,
+                    badge: nil,
+                    action: { SessionManager.kill(project: project) }
+                ))
+                // Recovery commands
+                projectCmds.append(PaletteCommand(
+                    id: "sync-\(project.id)",
+                    title: "Sync \(project.name)",
+                    subtitle: "Reconcile session to declared config",
+                    icon: "arrow.triangle.2.circlepath",
+                    category: .project,
+                    badge: nil,
+                    action: { SessionManager.sync(project: project) }
+                ))
+                // Per-pane restart commands
+                for paneName in project.paneNames {
+                    projectCmds.append(PaletteCommand(
+                        id: "restart-\(paneName)-\(project.id)",
+                        title: "Restart \(paneName) in \(project.name)",
+                        subtitle: "Kill and re-run the \(paneName) pane",
+                        icon: "arrow.counterclockwise",
+                        category: .project,
+                        badge: nil,
+                        action: { SessionManager.restart(project: project, paneName: paneName) }
+                    ))
+                }
+            } else {
+                projectCmds.append(PaletteCommand(
+                    id: "launch-\(project.id)",
+                    title: "Launch \(project.name)",
+                    subtitle: project.paneSummary.isEmpty
+                        ? (project.devCommand ?? project.path)
+                        : project.paneSummary,
+                    icon: "play.circle",
+                    category: .project,
+                    badge: nil,
+                    action: { SessionManager.launch(project: project) }
+                ))
+            }
+        }
+
+        // Move-to-space commands for running projects
+        let allSpaces = WindowTiler.getDisplaySpaces().flatMap(\.spaces)
+        if allSpaces.count > 1 {
+            for project in scanner.projects where project.isRunning {
+                let tag = Terminal.windowTag(for: project.sessionName)
+                var windowSpaces: [Int] = []
+                if let (w, _) = WindowTiler.findWindow(tag: tag) {
+                    windowSpaces = WindowTiler.getSpacesForWindow(w)
+                }
+
+                for space in allSpaces {
+                    let isCurrentSpace = windowSpaces.contains(space.id)
+                    windowCmds.append(PaletteCommand(
+                        id: "move-space\(space.index)-\(project.id)",
+                        title: "Move \(project.name) to Space \(space.index)",
+                        subtitle: isCurrentSpace ? "Window is already here" : "Move window to Space \(space.index)",
+                        icon: "rectangle.on.rectangle",
+                        category: .window,
+                        badge: isCurrentSpace ? "current" : nil,
+                        action: {
+                            let result = WindowTiler.moveWindowToSpace(
+                                session: project.sessionName,
+                                terminal: terminal,
+                                spaceId: space.id
+                            )
+                            if case .success = result {
+                                WindowTiler.switchToSpace(spaceId: space.id)
+                                DispatchQueue.main.asyncAfter(deadline: .now() + 0.3) {
+                                    WindowTiler.highlightWindow(session: project.sessionName)
+                                }
+                            }
+                        }
+                    ))
+                }
+            }
+        }
+
+        var commands = projectCmds + windowCmds
+
+        // Layer commands (focus + launch)
+        let workspace = WorkspaceManager.shared
+        if let wsConfig = workspace.config {
+            for (i, layer) in (wsConfig.layers ?? []).enumerated() {
+                let layerIndex = i
+                let isActive = i == workspace.activeLayerIndex
+                let counts = workspace.layerRunningCount(index: i)
+                commands.append(PaletteCommand(
+                    id: "layer-focus-\(layer.id)",
+                    title: "Focus Layer: \(layer.label)",
+                    subtitle: "\(counts.running)/\(counts.total) running \u{2014} \u{2325}\(i + 1)",
+                    icon: "square.stack.3d.up",
+                    category: .app,
+                    badge: isActive ? "active" : nil,
+                    action: { workspace.tileLayer(index: layerIndex) }
+                ))
+                commands.append(PaletteCommand(
+                    id: "layer-launch-\(layer.id)",
+                    title: "Launch Layer: \(layer.label)",
+                    subtitle: "Start all \(layer.projects.count) project\(layer.projects.count == 1 ? "" : "s")",
+                    icon: "play.circle",
+                    category: .app,
+                    badge: isActive ? "active" : nil,
+                    action: { workspace.tileLayer(index: layerIndex, launch: true) }
+                ))
+            }
+
+            // Tab group commands
+            for group in wsConfig.groups ?? [] {
+                let isRunning = workspace.isGroupRunning(group)
+
+                if isRunning {
+                    commands.append(PaletteCommand(
+                        id: "group-attach-\(group.id)",
+                        title: "Attach \(group.label)",
+                        subtitle: "\(group.tabs.count) tabs",
+                        icon: "rectangle.stack",
+                        category: .project,
+                        badge: "group",
+                        action: {
+                            if let firstTab = group.tabs.first {
+                                let session = WorkspaceManager.sessionName(for: firstTab.path)
+                                let terminal = Preferences.shared.terminal
+                                terminal.focusOrAttach(session: session)
+                            }
+                        }
+                    ))
+
+                    // Per-tab focus commands
+                    for (idx, tab) in group.tabs.enumerated() {
+                        let tabLabel = tab.label ?? (tab.path as NSString).lastPathComponent
+                        let tabIndex = idx
+                        commands.append(PaletteCommand(
+                            id: "group-tab-\(group.id)-\(idx)",
+                            title: "\(group.label): \(tabLabel)",
+                            subtitle: "Focus tab \(idx + 1) in group",
+                            icon: "rectangle.topthird.inset.filled",
+                            category: .project,
+                            badge: nil,
+                            action: {
+                                workspace.focusTab(group: group, tabIndex: tabIndex)
+                            }
+                        ))
+                    }
+
+                    commands.append(PaletteCommand(
+                        id: "group-kill-\(group.id)",
+                        title: "Kill \(group.label) Group",
+                        subtitle: "Terminate the group session",
+                        icon: "xmark.circle.fill",
+                        category: .window,
+                        badge: nil,
+                        action: {
+                            workspace.killGroup(group)
+                            DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) {
+                                scanner.refreshStatus()
+                            }
+                        }
+                    ))
+                } else {
+                    commands.append(PaletteCommand(
+                        id: "group-launch-\(group.id)",
+                        title: "Launch \(group.label)",
+                        subtitle: "\(group.tabs.count) tabs \u{2014} \(group.tabs.map { $0.label ?? ($0.path as NSString).lastPathComponent }.joined(separator: ", "))",
+                        icon: "rectangle.stack",
+                        category: .project,
+                        badge: "group",
+                        action: { workspace.launchGroup(group) }
+                    ))
+                }
+            }
+        }
+
+        // Orphan session commands
+        let inventory = InventoryManager.shared
+        for orphan in inventory.orphans {
+            commands.append(PaletteCommand(
+                id: "orphan-attach-\(orphan.name)",
+                title: "Attach \(orphan.name)",
+                subtitle: "\(orphan.panes.count) pane\(orphan.panes.count == 1 ? "" : "s") \u{2014} \(orphan.panes.prefix(3).map(\.currentCommand).joined(separator: ", "))",
+                icon: "play.fill",
+                category: .project,
+                badge: "orphan",
+                action: {
+                    let terminal = Preferences.shared.terminal
+                    terminal.focusOrAttach(session: orphan.name)
+                }
+            ))
+            commands.append(PaletteCommand(
+                id: "orphan-kill-\(orphan.name)",
+                title: "Kill \(orphan.name)",
+                subtitle: "Terminate unmanaged tmux session",
+                icon: "xmark.circle.fill",
+                category: .window,
+                badge: "orphan",
+                action: {
+                    SessionManager.killByName(orphan.name)
+                    DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) {
+                        inventory.refresh()
+                    }
+                }
+            ))
+        }
+
+        // App actions
+        commands.append(PaletteCommand(
+            id: "app-settings",
+            title: "Settings",
+            subtitle: "Terminal, scan root, mode",
+            icon: "gearshape",
+            category: .app,
+            badge: nil,
+            action: {
+                SettingsWindowController.shared.show()
+            }
+        ))
+
+        commands.append(PaletteCommand(
+            id: "app-windows-list",
+            title: "Windows List",
+            subtitle: "Browse all windows across displays",
+            icon: "rectangle.split.2x1",
+            category: .app,
+            badge: nil,
+            action: { CommandModeWindow.shared.show() }
+        ))
+
+        commands.append(PaletteCommand(
+            id: "app-screen-map",
+            title: "Window Map",
+            subtitle: "Visual window editor",
+            icon: "rectangle.3.group",
+            category: .app,
+            badge: nil,
+            action: { ScreenMapWindowController.shared.show() }
+        ))
+
+        commands.append(PaletteCommand(
+            id: "app-diagnostics",
+            title: "Diagnostics",
+            subtitle: "View logs and debug info",
+            icon: "stethoscope",
+            category: .app,
+            badge: nil,
+            action: { DiagnosticWindow.shared.show() }
+        ))
+
+        commands.append(PaletteCommand(
+            id: "app-refresh",
+            title: "Refresh Projects",
+            subtitle: "Re-scan for .lattices.json configs",
+            icon: "arrow.clockwise",
+            category: .app,
+            badge: nil,
+            action: { scanner.scan() }
+        ))
+
+        commands.append(PaletteCommand(
+            id: "app-quit",
+            title: "Quit Lattices",
+            subtitle: "Exit the menu bar app",
+            icon: "power",
+            category: .app,
+            badge: nil,
+            action: { NSApp.terminate(nil) }
+        ))
+
+        return commands
+    }
+}

package/app/Sources/PermissionChecker.swift

@@ -0,0 +1,125 @@
+import AppKit
+import SwiftUI
+import Combine
+
+final class PermissionChecker: ObservableObject {
+    static let shared = PermissionChecker()
+
+    @Published var accessibility: Bool = false
+    @Published var screenRecording: Bool = false
+
+    private var pollTimer: Timer?
+    private var hasLoggedInitial = false
+
+    var allGranted: Bool { accessibility && screenRecording }
+
+    /// Check current permission state, prompting on first launch if not granted.
+    func check() {
+        let diag = DiagnosticLog.shared
+
+        let ax = AXIsProcessTrusted()
+        let sr = CGPreflightScreenCaptureAccess()
+
+        // First check: log identity info and prompt if needed
+        if !hasLoggedInitial {
+            hasLoggedInitial = true
+            let bundleId = Bundle.main.bundleIdentifier ?? "<no bundle id>"
+            let execPath = Bundle.main.executablePath ?? ProcessInfo.processInfo.arguments.first ?? "<unknown>"
+            let pid = ProcessInfo.processInfo.processIdentifier
+            diag.info("PermissionChecker: bundleId=\(bundleId) pid=\(pid)")
+            diag.info("PermissionChecker: exec=\(execPath)")
+            diag.info("AXIsProcessTrusted() → \(ax)")
+            diag.info("CGPreflightScreenCaptureAccess() → \(sr)")
+
+            // Prompt for missing permissions on first check
+            if !ax {
+                requestAccessibility()
+                return
+            }
+            if !sr {
+                requestScreenRecording()
+                return
+            }
+        }
+
+        // Log on state changes
+        if ax != accessibility || sr != screenRecording {
+            diag.info("Permissions: Accessibility \(ax ? "✓" : "✗"), Screen Recording \(sr ? "✓" : "✗")")
+        }
+
+        accessibility = ax
+        screenRecording = sr
+
+        // If not all granted, start polling so we detect changes while user is in Settings.
+        // Once all granted, stop polling.
+        if allGranted {
+            stopPolling()
+        } else {
+            startPolling()
+        }
+    }
+
+    /// Request Accessibility permission — shows the system dialog if not yet granted,
+    /// which adds lattices to the Accessibility list and asks the user to toggle it on.
+    func requestAccessibility() {
+        let diag = DiagnosticLog.shared
+        let beforeCheck = AXIsProcessTrusted()
+        diag.info("requestAccessibility: before=\(beforeCheck), prompting…")
+        let opts = [kAXTrustedCheckOptionPrompt.takeUnretainedValue(): true] as CFDictionary
+        let result = AXIsProcessTrustedWithOptions(opts)
+        diag.info("AXIsProcessTrustedWithOptions(prompt) → \(result)")
+        accessibility = result
+        if !result {
+            diag.warn("Accessibility not granted — opening System Settings. Toggle ON in Privacy → Accessibility.")
+            openAccessibilitySettings()
+            startPolling()
+        }
+    }
+
+    /// Request Screen Recording permission — triggers the system prompt on first call,
+    /// which adds lattices to the Screen Recording list. The user toggles it on in Settings.
+    func requestScreenRecording() {
+        let diag = DiagnosticLog.shared
+        let beforeCheck = CGPreflightScreenCaptureAccess()
+        diag.info("requestScreenRecording: before=\(beforeCheck), prompting…")
+        let result = CGRequestScreenCaptureAccess()
+        diag.info("CGRequestScreenCaptureAccess() → \(result)")
+        screenRecording = result
+        if !result {
+            diag.warn("Screen Recording not granted — opening System Settings. Toggle ON in Privacy → Screen Recording.")
+            openScreenRecordingSettings()
+            startPolling()
+        }
+    }
+
+    /// Opens System Settings → Privacy & Security → Accessibility
+    func openAccessibilitySettings() {
+        if let url = URL(string: "x-apple.systempreferences:com.apple.preference.security?Privacy_Accessibility") {
+            NSWorkspace.shared.open(url)
+        }
+    }
+
+    /// Opens System Settings → Privacy & Security → Screen Recording
+    func openScreenRecordingSettings() {
+        if let url = URL(string: "x-apple.systempreferences:com.apple.preference.security?Privacy_ScreenCapture") {
+            NSWorkspace.shared.open(url)
+        }
+    }
+
+    // MARK: - Polling
+
+    /// Poll every 2 seconds to detect permission changes made in System Settings.
+    private func startPolling() {
+        guard pollTimer == nil else { return }
+        pollTimer = Timer.scheduledTimer(withTimeInterval: 2.0, repeats: true) { [weak self] _ in
+            DispatchQueue.main.async {
+                self?.check()
+            }
+        }
+    }
+
+    private func stopPolling() {
+        pollTimer?.invalidate()
+        pollTimer = nil
+    }
+}

package/app/Sources/Preferences.swift

@@ -0,0 +1,99 @@
+import Foundation
+
+enum InteractionMode: String {
+    case learning = "learning"
+    case auto = "auto"
+}
+
+class Preferences: ObservableObject {
+    static let shared = Preferences()
+
+    @Published var terminal: Terminal {
+        didSet { UserDefaults.standard.set(terminal.rawValue, forKey: "terminal") }
+    }
+
+    @Published var scanRoot: String {
+        didSet { UserDefaults.standard.set(scanRoot, forKey: "scanRoot") }
+    }
+
+    @Published var mode: InteractionMode {
+        didSet { UserDefaults.standard.set(mode.rawValue, forKey: "mode") }
+    }
+
+    // MARK: - Search & OCR
+
+    @Published var ocrEnabled: Bool {
+        didSet { UserDefaults.standard.set(!ocrEnabled, forKey: "ocr.disabled") }
+    }
+
+    @Published var ocrQuickInterval: Double {
+        didSet { UserDefaults.standard.set(ocrQuickInterval, forKey: "ocr.interval") }
+    }
+
+    @Published var ocrDeepInterval: Double {
+        didSet { UserDefaults.standard.set(ocrDeepInterval, forKey: "ocr.deepInterval") }
+    }
+
+    @Published var ocrQuickLimit: Int {
+        didSet { UserDefaults.standard.set(ocrQuickLimit, forKey: "ocr.quickLimit") }
+    }
+
+    @Published var ocrDeepLimit: Int {
+        didSet { UserDefaults.standard.set(ocrDeepLimit, forKey: "ocr.deepLimit") }
+    }
+
+    @Published var ocrDeepBudget: Int {
+        didSet { UserDefaults.standard.set(ocrDeepBudget, forKey: "ocr.deepBudget") }
+    }
+
+    @Published var ocrAccuracy: String {
+        didSet { UserDefaults.standard.set(ocrAccuracy, forKey: "ocr.accuracy") }
+    }
+
+    init() {
+        if let saved = UserDefaults.standard.string(forKey: "terminal"),
+           let t = Terminal(rawValue: saved), t.isInstalled {
+            self.terminal = t
+        } else {
+            self.terminal = Terminal.installed.first ?? .terminal
+        }
+
+        let savedRoot = UserDefaults.standard.string(forKey: "scanRoot") ?? ""
+        if savedRoot.isEmpty {
+            // Auto-detect a reasonable default
+            let home = NSHomeDirectory()
+            let candidates = ["\(home)/dev", "\(home)/Developer", "\(home)/projects", "\(home)/src"]
+            self.scanRoot = candidates.first { FileManager.default.fileExists(atPath: $0) } ?? ""
+        } else {
+            self.scanRoot = savedRoot
+        }
+
+        if let saved = UserDefaults.standard.string(forKey: "mode"),
+           let m = InteractionMode(rawValue: saved) {
+            self.mode = m
+        } else {
+            self.mode = .learning
+        }
+
+        // Search & OCR
+        self.ocrEnabled = !UserDefaults.standard.bool(forKey: "ocr.disabled")
+
+        let savedInterval = UserDefaults.standard.double(forKey: "ocr.interval")
+        self.ocrQuickInterval = savedInterval > 0 ? savedInterval : 60
+
+        let savedDeep = UserDefaults.standard.double(forKey: "ocr.deepInterval")
+        self.ocrDeepInterval = savedDeep > 0 ? savedDeep : 7200
+
+        let savedQL = UserDefaults.standard.integer(forKey: "ocr.quickLimit")
+        self.ocrQuickLimit = savedQL > 0 ? savedQL : 5
+
+        let savedDL = UserDefaults.standard.integer(forKey: "ocr.deepLimit")
+        self.ocrDeepLimit = savedDL > 0 ? savedDL : 15
+
+        let savedBudget = UserDefaults.standard.integer(forKey: "ocr.deepBudget")
+        self.ocrDeepBudget = savedBudget > 0 ? savedBudget : 3
+
+        let savedAcc = UserDefaults.standard.string(forKey: "ocr.accuracy") ?? "accurate"
+        self.ocrAccuracy = savedAcc
+    }
+}