@lattices/cli 0.3.0 → 0.4.0

package/app/Sources/OmniSearchState.swift

@@ -69,39 +69,110 @@ final class OmniSearchState: ObservableObject {
     private var debounceTimer: AnyCancellable?
 
     init() {
-        // Debounce search by 150ms
+        // Single-char queries fire immediately with a lightweight search;
+        // longer queries debounce 150ms and run the full search.
         debounceTimer = $query
-            .debounce(for: .milliseconds(150), scheduler: RunLoop.main)
+            .removeDuplicates()
             .sink { [weak self] q in
+                guard let self else { return }
+                self.fullSearchTask?.cancel()
                 if q.isEmpty {
-                    self?.results = []
-                    self?.refreshSummary()
+                    self.results = []
+                    self.refreshSummary()
+                } else if q.count == 1 {
+                    self.quickSearch(q)
                 } else {
-                    self?.search(q)
+                    self.fullSearchTask = DispatchWorkItem { [weak self] in
+                        self?.search(q)
+                    }
+                    DispatchQueue.main.asyncAfter(deadline: .now() + 0.15, execute: self.fullSearchTask!)
                 }
             }
 
         refreshSummary()
     }
 
-    // MARK: - Search
+    private var fullSearchTask: DispatchWorkItem?
+
+    // MARK: - Quick search (first character — window index only, no terminal/OCR/projects)
+
+    private func quickSearch(_ query: String) {
+        let q = query.lowercased()
+        let desktop = DesktopModel.shared
+        var all: [OmniResult] = []
+
+        for entry in desktop.allWindows() {
+            var score = 0
+            if entry.title.lowercased().contains(q) { score += 3 }
+            if entry.app.lowercased().contains(q) { score += 2 }
+            if entry.latticesSession?.lowercased().contains(q) == true { score += 3 }
+            guard score > 0 else { continue }
+
+            let wid = entry.wid
+            let pid = entry.pid
+            all.append(OmniResult(
+                kind: .window,
+                title: entry.app,
+                subtitle: entry.title.isEmpty ? "Window \(wid)" : entry.title,
+                icon: "macwindow",
+                score: score
+            ) {
+                WindowTiler.focusWindow(wid: wid, pid: pid)
+            })
+        }
+
+        all.sort { $0.score > $1.score }
+        results = Array(all.prefix(12))
+        selectedIndex = 0
+    }
+
+    // MARK: - Search (delegates to unified lattices.search API)
 
     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
+        // ── Daemon search: windows, terminals, OCR — single source of truth ──
+        // This is synchronous on the daemon's in-process API, not a network call.
+        if let json = try? LatticesApi.shared.dispatch(
+            method: "lattices.search",
+            params: .object(["query": .string(q)])
+        ), case .array(let hits) = json {
+            let desktop = DesktopModel.shared
+            for hit in hits {
+                guard let wid = hit["wid"]?.uint32Value else { continue }
+                let app = hit["app"]?.stringValue ?? ""
+                let title = hit["title"]?.stringValue ?? ""
+                let score = hit["score"]?.intValue ?? 0
+                let pid = desktop.windows[wid]?.pid ?? 0
+                let sources = (hit["matchSources"]?.arrayValue ?? []).compactMap(\.stringValue)
+
+                // Determine kind from match sources
+                let hasOcr = sources.contains("ocr")
+                let hasTerminal = !Set(sources).isDisjoint(with: ["cwd", "tab", "tmux", "process"])
+                let kind: OmniResultKind = hasOcr ? .ocrContent : hasTerminal ? .session : .window
+
+                let icon: String
+                let subtitle: String
+                switch kind {
+                case .ocrContent:
+                    icon = "doc.text.magnifyingglass"
+                    subtitle = hit["ocrSnippet"]?.stringValue ?? title
+                case .session:
+                    icon = "terminal"
+                    let tabs = hit["terminalTabs"]?.arrayValue ?? []
+                    let cwds = tabs.compactMap { $0["cwd"]?.stringValue }
+                    subtitle = cwds.first ?? title
+                default:
+                    icon = "macwindow"
+                    subtitle = title.isEmpty ? "Window \(wid)" : title
+                }
+
                 all.append(OmniResult(
-                    kind: .window,
-                    title: win.app,
-                    subtitle: win.title.isEmpty ? "Window \(win.wid)" : win.title,
-                    icon: "macwindow",
+                    kind: kind,
+                    title: app,
+                    subtitle: subtitle,
+                    icon: icon,
                     score: score
                 ) {
                     WindowTiler.focusWindow(wid: wid, pid: pid)
@@ -109,10 +180,9 @@ final class OmniSearchState: ObservableObject {
             }
         }
 
-        // Projects
-        let scanner = ProjectScanner.shared
-        for project in scanner.projects {
-            let score = scoreMatch(q, against: [project.name, project.path])
+        // ── Projects: local-only (not window-centric, so not in daemon search) ──
+        for project in ProjectScanner.shared.projects {
+            let score = scoreProjectMatch(q, name: project.name, path: project.path)
             if score > 0 {
                 let proj = project
                 all.append(OmniResult(
@@ -127,93 +197,20 @@ final class OmniSearchState: ObservableObject {
             }
         }
 
-        // 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
-    }
+    // MARK: - Project scoring (local — projects aren't windows)
 
-    private func scoreOcr(_ query: String, fullText: String) -> Int {
-        let lower = fullText.lowercased()
-        if lower.contains(query) { return 40 }
+    private func scoreProjectMatch(_ query: String, name: String, path: String) -> Int {
+        let lowerName = name.lowercased()
+        let lowerPath = path.lowercased()
+        if lowerName == query { return 100 }
+        if lowerName.hasPrefix(query) { return 80 }
+        if lowerName.contains(query) { return 60 }
+        if lowerPath.contains(query) { return 40 }
         return 0
     }
 

package/app/Sources/OnboardingView.swift

@@ -0,0 +1,457 @@
+import SwiftUI
+import AppKit
+
+// MARK: - Onboarding Flow
+
+/// A step-by-step welcome screen shown on first launch.
+/// Walks the user through granting Accessibility, Screen Recording,
+/// choosing a project root, and optionally installing tmux.
+struct OnboardingView: View {
+    @ObservedObject private var permChecker = PermissionChecker.shared
+    @ObservedObject private var prefs = Preferences.shared
+    @ObservedObject private var tmux = TmuxModel.shared
+    @State private var step: Step = .welcome
+    var onComplete: () -> Void
+
+    enum Step: Int, CaseIterable {
+        case welcome
+        case accessibility
+        case screenRecording
+        case projectRoot
+        case tmux
+        case done
+    }
+
+    var body: some View {
+        VStack(spacing: 0) {
+            // Progress dots
+            HStack(spacing: 6) {
+                ForEach(Step.allCases, id: \.rawValue) { s in
+                    Circle()
+                        .fill(s.rawValue <= step.rawValue ? Color.white : Color.white.opacity(0.20))
+                        .frame(width: 6, height: 6)
+                }
+            }
+            .padding(.top, 28)
+            .padding(.bottom, 24)
+
+            // Step content
+            Group {
+                switch step {
+                case .welcome:      welcomeStep
+                case .accessibility: accessibilityStep
+                case .screenRecording: screenRecordingStep
+                case .projectRoot:  projectRootStep
+                case .tmux:         tmuxStep
+                case .done:         doneStep
+                }
+            }
+            .frame(maxWidth: .infinity, maxHeight: .infinity)
+            .padding(.horizontal, 40)
+
+            Spacer(minLength: 0)
+
+            // Navigation
+            HStack {
+                if step != .welcome {
+                    Button("Back") { withAnimation(.easeInOut(duration: 0.2)) { goBack() } }
+                        .buttonStyle(.plain)
+                        .font(Typo.mono(11))
+                        .foregroundColor(Palette.textMuted)
+                }
+                Spacer()
+                if step == .done {
+                    Button(action: { onComplete() }) {
+                        Text("Get started")
+                            .angularButton(Palette.running)
+                    }
+                    .buttonStyle(.plain)
+                } else {
+                    Button(action: { withAnimation(.easeInOut(duration: 0.2)) { advance() } }) {
+                        Text(nextLabel)
+                            .angularButton(.white)
+                    }
+                    .buttonStyle(.plain)
+                }
+            }
+            .padding(.horizontal, 40)
+            .padding(.bottom, 28)
+        }
+        .frame(width: 480, height: 420)
+        .background(Palette.bg)
+        .preferredColorScheme(.dark)
+    }
+
+    // MARK: - Steps
+
+    private var welcomeStep: some View {
+        VStack(spacing: 16) {
+            latticesIcon
+            Text("Welcome to Lattices")
+                .font(Typo.title(18))
+                .foregroundColor(Palette.text)
+            Text("Workspace control plane for macOS.\nLet's get you set up in under a minute.")
+                .font(Typo.body(12))
+                .foregroundColor(Palette.textDim)
+                .multilineTextAlignment(.center)
+                .lineSpacing(3)
+        }
+    }
+
+    private var accessibilityStep: some View {
+        permissionStep(
+            icon: "hand.raised.fill",
+            title: "Accessibility",
+            description: "Lattices needs Accessibility access to read window titles, move and resize windows, and tile your workspace.",
+            granted: permChecker.accessibility,
+            action: { permChecker.requestAccessibility() }
+        )
+    }
+
+    private var screenRecordingStep: some View {
+        permissionStep(
+            icon: "rectangle.dashed.badge.record",
+            title: "Screen Recording",
+            description: "Allows Lattices to index on-screen text with OCR so you can search across all your windows.",
+            granted: permChecker.screenRecording,
+            action: { permChecker.requestScreenRecording() }
+        )
+    }
+
+    private var projectRootStep: some View {
+        VStack(spacing: 16) {
+            Image(systemName: "folder.fill")
+                .font(.system(size: 28))
+                .foregroundColor(.white.opacity(0.7))
+
+            Text("Project directory")
+                .font(Typo.title(16))
+                .foregroundColor(Palette.text)
+
+            Text("Where do your projects live? Lattices scans this folder to find workspaces.")
+                .font(Typo.body(12))
+                .foregroundColor(Palette.textDim)
+                .multilineTextAlignment(.center)
+                .lineSpacing(3)
+
+            HStack(spacing: 8) {
+                Text(prefs.scanRoot.isEmpty ? "Not set" : abbreviatePath(prefs.scanRoot))
+                    .font(Typo.mono(11))
+                    .foregroundColor(prefs.scanRoot.isEmpty ? Palette.textMuted : Palette.text)
+                    .lineLimit(1)
+                    .truncationMode(.middle)
+                    .frame(maxWidth: .infinity, alignment: .leading)
+                    .padding(.horizontal, 10)
+                    .padding(.vertical, 8)
+                    .background(
+                        RoundedRectangle(cornerRadius: 5)
+                            .fill(Palette.surface)
+                            .overlay(
+                                RoundedRectangle(cornerRadius: 5)
+                                    .strokeBorder(Palette.border, lineWidth: 0.5)
+                            )
+                    )
+
+                Button("Browse") {
+                    let panel = NSOpenPanel()
+                    panel.canChooseFiles = false
+                    panel.canChooseDirectories = true
+                    panel.allowsMultipleSelection = false
+                    panel.directoryURL = URL(fileURLWithPath: prefs.scanRoot.isEmpty ? NSHomeDirectory() : prefs.scanRoot)
+                    if panel.runModal() == .OK, let url = panel.url {
+                        prefs.scanRoot = url.path
+                    }
+                }
+                .buttonStyle(.plain)
+                .font(Typo.monoBold(10))
+                .foregroundColor(.white)
+                .padding(.horizontal, 10)
+                .padding(.vertical, 6)
+                .background(
+                    RoundedRectangle(cornerRadius: 5)
+                        .fill(Palette.surface)
+                        .overlay(
+                            RoundedRectangle(cornerRadius: 5)
+                                .strokeBorder(Palette.borderLit, lineWidth: 0.5)
+                        )
+                )
+            }
+
+            if !prefs.scanRoot.isEmpty {
+                HStack(spacing: 4) {
+                    Image(systemName: "checkmark.circle.fill")
+                        .font(.system(size: 10))
+                        .foregroundColor(Palette.running)
+                    Text(abbreviatePath(prefs.scanRoot))
+                        .font(Typo.mono(10))
+                        .foregroundColor(Palette.running)
+                }
+            }
+        }
+    }
+
+    private var tmuxStep: some View {
+        VStack(spacing: 16) {
+            Image(systemName: "terminal.fill")
+                .font(.system(size: 28))
+                .foregroundColor(.white.opacity(0.7))
+
+            Text("Terminal sessions")
+                .font(Typo.title(16))
+                .foregroundColor(Palette.text)
+
+            if tmux.isAvailable {
+                HStack(spacing: 6) {
+                    Image(systemName: "checkmark.circle.fill")
+                        .foregroundColor(Palette.running)
+                    Text("tmux is installed")
+                        .font(Typo.mono(12))
+                        .foregroundColor(Palette.running)
+                }
+                Text("Lattices can manage tmux sessions, pane layouts, and terminal workspaces for you.")
+                    .font(Typo.body(12))
+                    .foregroundColor(Palette.textDim)
+                    .multilineTextAlignment(.center)
+                    .lineSpacing(3)
+            } else {
+                Text("tmux is optional but recommended. It enables managed terminal sessions with persistent pane layouts.")
+                    .font(Typo.body(12))
+                    .foregroundColor(Palette.textDim)
+                    .multilineTextAlignment(.center)
+                    .lineSpacing(3)
+
+                Button(action: {
+                    let task = Process()
+                    task.executableURL = URL(fileURLWithPath: "/bin/zsh")
+                    task.arguments = ["-lc", "brew install tmux"]
+                    task.standardOutput = FileHandle.nullDevice
+                    task.standardError = FileHandle.nullDevice
+                    try? task.run()
+                }) {
+                    HStack(spacing: 6) {
+                        Image(systemName: "arrow.down.circle")
+                            .font(.system(size: 11))
+                        Text("brew install tmux")
+                            .font(Typo.monoBold(11))
+                    }
+                    .angularButton(.white, filled: false)
+                }
+                .buttonStyle(.plain)
+
+                Text("You can always install it later. Window tiling, search, and OCR work without tmux.")
+                    .font(Typo.mono(10))
+                    .foregroundColor(Palette.textMuted)
+                    .multilineTextAlignment(.center)
+                    .lineSpacing(2)
+            }
+        }
+    }
+
+    private var doneStep: some View {
+        VStack(spacing: 16) {
+            Image(systemName: "checkmark.circle.fill")
+                .font(.system(size: 36))
+                .foregroundColor(Palette.running)
+
+            Text("You're all set")
+                .font(Typo.title(18))
+                .foregroundColor(Palette.text)
+
+            VStack(alignment: .leading, spacing: 8) {
+                statusRow("Accessibility", granted: permChecker.accessibility)
+                statusRow("Screen Recording", granted: permChecker.screenRecording)
+                statusRow("Project root", granted: !prefs.scanRoot.isEmpty,
+                          detail: prefs.scanRoot.isEmpty ? "not set" : abbreviatePath(prefs.scanRoot))
+                statusRow("tmux", granted: tmux.isAvailable,
+                          detail: tmux.isAvailable ? "installed" : "skipped")
+            }
+            .padding(16)
+            .background(
+                RoundedRectangle(cornerRadius: 6)
+                    .fill(Palette.surface)
+                    .overlay(
+                        RoundedRectangle(cornerRadius: 6)
+                            .strokeBorder(Palette.border, lineWidth: 0.5)
+                    )
+            )
+        }
+    }
+
+    // MARK: - Shared helpers
+
+    private func permissionStep(icon: String, title: String, description: String, granted: Bool, action: @escaping () -> Void) -> some View {
+        VStack(spacing: 16) {
+            Image(systemName: icon)
+                .font(.system(size: 28))
+                .foregroundColor(.white.opacity(0.7))
+
+            Text(title)
+                .font(Typo.title(16))
+                .foregroundColor(Palette.text)
+
+            Text(description)
+                .font(Typo.body(12))
+                .foregroundColor(Palette.textDim)
+                .multilineTextAlignment(.center)
+                .lineSpacing(3)
+
+            if granted {
+                HStack(spacing: 6) {
+                    Image(systemName: "checkmark.circle.fill")
+                        .foregroundColor(Palette.running)
+                    Text("Granted")
+                        .font(Typo.monoBold(11))
+                        .foregroundColor(Palette.running)
+                }
+            } else {
+                Button(action: action) {
+                    Text("Grant \(title)")
+                        .angularButton(.white, filled: false)
+                }
+                .buttonStyle(.plain)
+
+                Text("macOS will ask you to toggle this on in System Settings.")
+                    .font(Typo.mono(10))
+                    .foregroundColor(Palette.textMuted)
+                    .multilineTextAlignment(.center)
+            }
+        }
+    }
+
+    private func statusRow(_ label: String, granted: Bool, detail: String? = nil) -> some View {
+        HStack(spacing: 8) {
+            Image(systemName: granted ? "checkmark.circle.fill" : "circle")
+                .font(.system(size: 11))
+                .foregroundColor(granted ? Palette.running : Palette.detach)
+            Text(label)
+                .font(Typo.mono(11))
+                .foregroundColor(Palette.text)
+            Spacer()
+            if let detail {
+                Text(detail)
+                    .font(Typo.mono(10))
+                    .foregroundColor(granted ? Palette.textDim : Palette.detach)
+            } else {
+                Text(granted ? "granted" : "not set")
+                    .font(Typo.mono(10))
+                    .foregroundColor(granted ? Palette.running : Palette.detach)
+            }
+        }
+    }
+
+    private var latticesIcon: some View {
+        // 3x3 grid — L-shape pattern
+        let cells = [true, false, false, true, false, false, true, true, true]
+        let size: CGFloat = 40
+        let pad: CGFloat = 4
+        let gap: CGFloat = 2.5
+        let cell = (size - 2 * pad - 2 * gap) / 3
+        return Canvas { context, _ in
+            for (i, bright) in cells.enumerated() {
+                let row = i / 3
+                let col = i % 3
+                let rect = CGRect(
+                    x: pad + CGFloat(col) * (cell + gap),
+                    y: pad + CGFloat(row) * (cell + gap),
+                    width: cell, height: cell
+                )
+                context.fill(
+                    RoundedRectangle(cornerRadius: 2).path(in: rect),
+                    with: .color(bright ? .white : .white.opacity(0.18))
+                )
+            }
+        }
+        .frame(width: size, height: size)
+    }
+
+    // MARK: - Navigation
+
+    private var nextLabel: String {
+        switch step {
+        case .accessibility where !permChecker.accessibility: return "Continue anyway"
+        case .screenRecording where !permChecker.screenRecording: return "Continue anyway"
+        case .projectRoot where prefs.scanRoot.isEmpty: return "Skip for now"
+        case .tmux where !tmux.isAvailable: return "Skip"
+        default: return "Continue"
+        }
+    }
+
+    private func advance() {
+        guard let next = Step(rawValue: step.rawValue + 1) else { return }
+        step = next
+    }
+
+    private func goBack() {
+        guard let prev = Step(rawValue: step.rawValue - 1) else { return }
+        step = prev
+    }
+
+    private func abbreviatePath(_ path: String) -> String {
+        let home = NSHomeDirectory()
+        if path.hasPrefix(home) {
+            return "~" + path.dropFirst(home.count)
+        }
+        return path
+    }
+}
+
+// MARK: - Window Controller
+
+final class OnboardingWindowController {
+    static let shared = OnboardingWindowController()
+
+    private var window: NSWindow?
+    private static let completedKey = "onboarding.completed"
+
+    var hasCompleted: Bool {
+        UserDefaults.standard.bool(forKey: Self.completedKey)
+    }
+
+    /// Show the onboarding window if not yet completed.
+    /// Returns true if onboarding was shown.
+    @discardableResult
+    func showIfNeeded() -> Bool {
+        guard !hasCompleted else { return false }
+        show()
+        return true
+    }
+
+    func show() {
+        if let w = window {
+            w.makeKeyAndOrderFront(nil)
+            NSApp.activate(ignoringOtherApps: true)
+            return
+        }
+
+        let view = OnboardingView {
+            self.complete()
+        }
+
+        let w = AppWindowShell.makeWindow(
+            config: .init(
+                title: "Welcome to Lattices",
+                titleVisible: false,
+                initialSize: NSSize(width: 480, height: 420),
+                minSize: NSSize(width: 480, height: 420),
+                maxSize: NSSize(width: 480, height: 420),
+                miniaturizable: false
+            ),
+            rootView: view
+        )
+        w.styleMask.remove(.resizable)
+        AppWindowShell.positionCentered(w)
+        AppWindowShell.present(w)
+        self.window = w
+    }
+
+    private func complete() {
+        UserDefaults.standard.set(true, forKey: Self.completedKey)
+        window?.orderOut(nil)
+        window = nil
+        AppDelegate.updateActivationPolicy()
+    }
+
+    func reset() {
+        UserDefaults.standard.removeObject(forKey: Self.completedKey)
+    }
+}