@arach/lattices 0.1.0 → 0.2.0

package/app/Sources/OmniSearchState.swift

@@ -0,0 +1,283 @@
+import AppKit
+import Combine
+import Foundation
+
+// MARK: - Result Types
+
+enum OmniResultKind: String {
+    case window
+    case project
+    case session
+    case process
+    case ocrContent
+}
+
+struct OmniResult: Identifiable {
+    let id = UUID()
+    let kind: OmniResultKind
+    let title: String
+    let subtitle: String
+    let icon: String
+    let score: Int           // higher = better match
+    let action: () -> Void
+
+    /// Group label for display
+    var groupLabel: String {
+        switch kind {
+        case .window:     return "Windows"
+        case .project:    return "Projects"
+        case .session:    return "Sessions"
+        case .process:    return "Processes"
+        case .ocrContent: return "Screen Text"
+        }
+    }
+}
+
+// MARK: - Activity Summary
+
+struct ActivitySummary {
+    struct AppWindowCount: Identifiable {
+        let id: String
+        let appName: String
+        let count: Int
+    }
+
+    struct SessionInfo: Identifiable {
+        let id: String
+        let name: String
+        let paneCount: Int
+        let attached: Bool
+    }
+
+    let windowsByApp: [AppWindowCount]
+    let totalWindows: Int
+    let sessions: [SessionInfo]
+    let interestingProcesses: [ProcessEntry]
+    let lastOcrScan: Date?
+    let ocrWindowCount: Int
+}
+
+// MARK: - State
+
+final class OmniSearchState: ObservableObject {
+    @Published var query: String = ""
+    @Published var results: [OmniResult] = []
+    @Published var selectedIndex: Int = 0
+    @Published var activitySummary: ActivitySummary?
+
+    private var cancellables = Set<AnyCancellable>()
+    private var debounceTimer: AnyCancellable?
+
+    init() {
+        // Debounce search by 150ms
+        debounceTimer = $query
+            .debounce(for: .milliseconds(150), scheduler: RunLoop.main)
+            .sink { [weak self] q in
+                if q.isEmpty {
+                    self?.results = []
+                    self?.refreshSummary()
+                } else {
+                    self?.search(q)
+                }
+            }
+
+        refreshSummary()
+    }
+
+    // MARK: - Search
+
+    private func search(_ query: String) {
+        let q = query.lowercased()
+        var all: [OmniResult] = []
+
+        // Windows
+        let desktop = DesktopModel.shared
+        for win in desktop.allWindows() {
+            let score = scoreMatch(q, against: [win.app, win.title])
+            if score > 0 {
+                let wid = win.wid
+                let pid = win.pid
+                all.append(OmniResult(
+                    kind: .window,
+                    title: win.app,
+                    subtitle: win.title.isEmpty ? "Window \(win.wid)" : win.title,
+                    icon: "macwindow",
+                    score: score
+                ) {
+                    WindowTiler.focusWindow(wid: wid, pid: pid)
+                })
+            }
+        }
+
+        // Projects
+        let scanner = ProjectScanner.shared
+        for project in scanner.projects {
+            let score = scoreMatch(q, against: [project.name, project.path])
+            if score > 0 {
+                let proj = project
+                all.append(OmniResult(
+                    kind: .project,
+                    title: project.name,
+                    subtitle: project.path,
+                    icon: "folder",
+                    score: score
+                ) {
+                    SessionManager.launch(project: proj)
+                })
+            }
+        }
+
+        // Tmux Sessions
+        let tmux = TmuxModel.shared
+        for session in tmux.sessions {
+            let paneCommands = session.panes.map(\.currentCommand)
+            let score = scoreMatch(q, against: [session.name] + paneCommands)
+            if score > 0 {
+                let name = session.name
+                all.append(OmniResult(
+                    kind: .session,
+                    title: session.name,
+                    subtitle: "\(session.windowCount) windows, \(session.panes.count) panes\(session.attached ? " (attached)" : "")",
+                    icon: "terminal",
+                    score: score
+                ) {
+                    let terminal = Preferences.shared.terminal
+                    terminal.focusOrAttach(session: name)
+                })
+            }
+        }
+
+        // Processes
+        let processes = ProcessModel.shared
+        for proc in processes.interesting {
+            let score = scoreMatch(q, against: [proc.comm, proc.args, proc.cwd ?? ""])
+            if score > 0 {
+                all.append(OmniResult(
+                    kind: .process,
+                    title: proc.comm,
+                    subtitle: proc.cwd ?? proc.args,
+                    icon: "gearshape",
+                    score: score
+                ) {
+                    // No direct action for processes — just informational
+                })
+            }
+        }
+
+        // OCR content
+        let ocr = OcrModel.shared
+        for (_, result) in ocr.results {
+            let ocrScore = scoreOcr(q, fullText: result.fullText)
+            if ocrScore > 0 {
+                let wid = result.wid
+                let pid = desktop.windows[wid]?.pid ?? 0
+                // Find matching line for subtitle
+                let matchLine = result.texts
+                    .first { $0.text.lowercased().contains(q) }?
+                    .text ?? String(result.fullText.prefix(80))
+                all.append(OmniResult(
+                    kind: .ocrContent,
+                    title: "\(result.app) — \(result.title)",
+                    subtitle: matchLine,
+                    icon: "doc.text.magnifyingglass",
+                    score: ocrScore
+                ) {
+                    WindowTiler.focusWindow(wid: wid, pid: pid)
+                })
+            }
+        }
+
+        // Sort by score descending
+        all.sort { $0.score > $1.score }
+
+        results = all
+        selectedIndex = 0
+    }
+
+    // MARK: - Scoring
+
+    private func scoreMatch(_ query: String, against fields: [String]) -> Int {
+        var best = 0
+        for field in fields {
+            let lower = field.lowercased()
+            if lower == query {
+                best = max(best, 100)  // exact
+            } else if lower.hasPrefix(query) {
+                best = max(best, 80)   // prefix
+            } else if lower.contains(query) {
+                best = max(best, 60)   // contains
+            }
+        }
+        return best
+    }
+
+    private func scoreOcr(_ query: String, fullText: String) -> Int {
+        let lower = fullText.lowercased()
+        if lower.contains(query) { return 40 }
+        return 0
+    }
+
+    // MARK: - Navigation
+
+    func moveSelection(_ delta: Int) {
+        guard !results.isEmpty else { return }
+        selectedIndex = max(0, min(results.count - 1, selectedIndex + delta))
+    }
+
+    func activateSelected() {
+        guard selectedIndex >= 0, selectedIndex < results.count else { return }
+        results[selectedIndex].action()
+    }
+
+    // MARK: - Activity Summary
+
+    func refreshSummary() {
+        let desktop = DesktopModel.shared
+        let windows = desktop.allWindows()
+
+        // Group by app
+        var appCounts: [String: Int] = [:]
+        for win in windows {
+            appCounts[win.app, default: 0] += 1
+        }
+        let windowsByApp = appCounts
+            .sorted { $0.value > $1.value }
+            .map { ActivitySummary.AppWindowCount(id: $0.key, appName: $0.key, count: $0.value) }
+
+        // Sessions
+        let sessions = TmuxModel.shared.sessions.map {
+            ActivitySummary.SessionInfo(
+                id: $0.id,
+                name: $0.name,
+                paneCount: $0.panes.count,
+                attached: $0.attached
+            )
+        }
+
+        // Processes
+        let procs = ProcessModel.shared.interesting
+
+        // OCR info
+        let ocrResults = OcrModel.shared.results
+        let lastScan: Date? = ocrResults.values.map(\.timestamp).max()
+
+        activitySummary = ActivitySummary(
+            windowsByApp: windowsByApp,
+            totalWindows: windows.count,
+            sessions: sessions,
+            interestingProcesses: procs,
+            lastOcrScan: lastScan,
+            ocrWindowCount: ocrResults.count
+        )
+    }
+
+    /// Grouped results for display
+    var groupedResults: [(String, [OmniResult])] {
+        let groups = Dictionary(grouping: results) { $0.groupLabel }
+        let order: [String] = ["Windows", "Projects", "Sessions", "Processes", "Screen Text"]
+        return order.compactMap { key in
+            guard let items = groups[key], !items.isEmpty else { return nil }
+            return (key, items)
+        }
+    }
+}

package/app/Sources/OmniSearchView.swift

@@ -0,0 +1,288 @@
+import SwiftUI
+
+struct OmniSearchView: View {
+    @ObservedObject var state: OmniSearchState
+    var onDismiss: () -> Void
+
+    @FocusState private var searchFocused: Bool
+
+    var body: some View {
+        VStack(spacing: 0) {
+            // Search field
+            HStack(spacing: 8) {
+                Image(systemName: "magnifyingglass")
+                    .foregroundColor(Palette.textMuted)
+                    .font(.system(size: 13))
+
+                TextField("Search windows, projects, sessions...", text: $state.query)
+                    .textFieldStyle(.plain)
+                    .font(Typo.mono(14))
+                    .foregroundColor(Palette.text)
+                    .focused($searchFocused)
+
+                if !state.query.isEmpty {
+                    Button { state.query = "" } label: {
+                        Image(systemName: "xmark.circle.fill")
+                            .foregroundColor(Palette.textMuted)
+                            .font(.system(size: 12))
+                    }
+                    .buttonStyle(.plain)
+                }
+            }
+            .padding(.horizontal, 14)
+            .padding(.vertical, 12)
+            .background(Palette.surface)
+
+            Rectangle()
+                .fill(Palette.border)
+                .frame(height: 0.5)
+
+            // Content
+            if state.query.isEmpty {
+                summaryView
+            } else if state.results.isEmpty {
+                emptyResults
+            } else {
+                resultsView
+            }
+        }
+        .frame(minWidth: 520, idealWidth: 520, maxWidth: 700, minHeight: 360, idealHeight: 480, maxHeight: 600)
+        .background(PanelBackground())
+        .preferredColorScheme(.dark)
+        .onAppear {
+            searchFocused = true
+            state.refreshSummary()
+        }
+    }
+
+    // MARK: - Results
+
+    private var resultsView: some View {
+        ScrollViewReader { proxy in
+            ScrollView {
+                LazyVStack(alignment: .leading, spacing: 2) {
+                    var flatIndex = 0
+                    ForEach(state.groupedResults, id: \.0) { group, items in
+                        // Group header
+                        Text(group.uppercased())
+                            .font(Typo.caption(9))
+                            .foregroundColor(Palette.textMuted)
+                            .padding(.horizontal, 14)
+                            .padding(.top, 8)
+                            .padding(.bottom, 2)
+
+                        ForEach(items) { item in
+                            let idx = flatIndex
+                            let _ = { flatIndex += 1 }()
+                            resultRow(item, index: idx)
+                                .id(item.id)
+                        }
+                    }
+                }
+                .padding(.vertical, 4)
+            }
+            .onChange(of: state.selectedIndex) { newVal in
+                if newVal < state.results.count {
+                    let item = state.results[newVal]
+                    withAnimation(.easeOut(duration: 0.1)) {
+                        proxy.scrollTo(item.id, anchor: .center)
+                    }
+                }
+            }
+        }
+    }
+
+    private func resultRow(_ item: OmniResult, index: Int) -> some View {
+        let isSelected = index == state.selectedIndex
+        return Button {
+            item.action()
+            onDismiss()
+        } label: {
+            HStack(spacing: 10) {
+                Image(systemName: item.icon)
+                    .font(.system(size: 11, weight: .medium))
+                    .foregroundColor(isSelected ? Palette.text : Palette.textDim)
+                    .frame(width: 16)
+
+                VStack(alignment: .leading, spacing: 1) {
+                    Text(item.title)
+                        .font(Typo.mono(12))
+                        .foregroundColor(isSelected ? Palette.text : Palette.textDim)
+                        .lineLimit(1)
+
+                    Text(item.subtitle)
+                        .font(Typo.mono(10))
+                        .foregroundColor(Palette.textMuted)
+                        .lineLimit(1)
+                }
+
+                Spacer()
+
+                Text(item.kind.rawValue)
+                    .font(Typo.mono(9))
+                    .foregroundColor(Palette.textMuted)
+                    .padding(.horizontal, 5)
+                    .padding(.vertical, 2)
+                    .background(
+                        RoundedRectangle(cornerRadius: 3)
+                            .fill(Palette.surface)
+                    )
+            }
+            .padding(.horizontal, 14)
+            .padding(.vertical, 6)
+            .background(
+                RoundedRectangle(cornerRadius: 5)
+                    .fill(isSelected ? Palette.surfaceHov : Color.clear)
+            )
+            .contentShape(Rectangle())
+        }
+        .buttonStyle(.plain)
+    }
+
+    // MARK: - Empty Results
+
+    private var emptyResults: some View {
+        VStack(spacing: 12) {
+            Spacer()
+            Image(systemName: "magnifyingglass")
+                .font(.system(size: 24, weight: .light))
+                .foregroundColor(Palette.textMuted)
+            Text("No results for \"\(state.query)\"")
+                .font(Typo.mono(12))
+                .foregroundColor(Palette.textDim)
+            Spacer()
+        }
+    }
+
+    // MARK: - Activity Summary
+
+    private var summaryView: some View {
+        ScrollView {
+            VStack(alignment: .leading, spacing: 14) {
+                if let summary = state.activitySummary {
+                    // Windows by app
+                    summarySection("WINDOWS", icon: "macwindow", count: summary.totalWindows) {
+                        ForEach(summary.windowsByApp) { app in
+                            HStack {
+                                Text(app.appName)
+                                    .font(Typo.mono(11))
+                                    .foregroundColor(Palette.textDim)
+                                    .lineLimit(1)
+                                Spacer()
+                                Text("\(app.count)")
+                                    .font(Typo.monoBold(11))
+                                    .foregroundColor(Palette.text)
+                            }
+                        }
+                    }
+
+                    // Sessions
+                    if !summary.sessions.isEmpty {
+                        summarySection("TMUX SESSIONS", icon: "terminal", count: summary.sessions.count) {
+                            ForEach(summary.sessions) { session in
+                                HStack {
+                                    Circle()
+                                        .fill(session.attached ? Palette.running : Palette.textMuted)
+                                        .frame(width: 6, height: 6)
+                                    Text(session.name)
+                                        .font(Typo.mono(11))
+                                        .foregroundColor(Palette.textDim)
+                                    Spacer()
+                                    Text("\(session.paneCount) panes")
+                                        .font(Typo.mono(10))
+                                        .foregroundColor(Palette.textMuted)
+                                }
+                            }
+                        }
+                    }
+
+                    // Processes
+                    if !summary.interestingProcesses.isEmpty {
+                        summarySection("PROCESSES", icon: "gearshape", count: summary.interestingProcesses.count) {
+                            ForEach(Array(summary.interestingProcesses.prefix(10).enumerated()), id: \.offset) { _, proc in
+                                HStack {
+                                    Text(proc.comm)
+                                        .font(Typo.monoBold(11))
+                                        .foregroundColor(Palette.textDim)
+                                    if let cwd = proc.cwd {
+                                        Text(cwd.replacingOccurrences(of: NSHomeDirectory(), with: "~"))
+                                            .font(Typo.mono(10))
+                                            .foregroundColor(Palette.textMuted)
+                                            .lineLimit(1)
+                                    }
+                                    Spacer()
+                                }
+                            }
+                        }
+                    }
+
+                    // OCR info
+                    if summary.ocrWindowCount > 0 {
+                        HStack(spacing: 6) {
+                            Image(systemName: "doc.text.magnifyingglass")
+                                .font(.system(size: 10))
+                                .foregroundColor(Palette.textMuted)
+                            Text("OCR: \(summary.ocrWindowCount) windows scanned")
+                                .font(Typo.mono(10))
+                                .foregroundColor(Palette.textMuted)
+                            if let t = summary.lastOcrScan {
+                                Spacer()
+                                Text(relativeTime(t))
+                                    .font(Typo.mono(9))
+                                    .foregroundColor(Palette.textMuted)
+                            }
+                        }
+                        .padding(.horizontal, 14)
+                    }
+                } else {
+                    Text("Loading...")
+                        .font(Typo.mono(11))
+                        .foregroundColor(Palette.textMuted)
+                        .padding(14)
+                }
+            }
+            .padding(.vertical, 10)
+        }
+    }
+
+    private func summarySection<Content: View>(
+        _ title: String,
+        icon: String,
+        count: Int,
+        @ViewBuilder content: () -> Content
+    ) -> some View {
+        VStack(alignment: .leading, spacing: 6) {
+            HStack(spacing: 6) {
+                Image(systemName: icon)
+                    .font(.system(size: 10, weight: .medium))
+                    .foregroundColor(Palette.textMuted)
+                Text(title)
+                    .font(Typo.caption(9))
+                    .foregroundColor(Palette.textMuted)
+                Text("\(count)")
+                    .font(Typo.monoBold(9))
+                    .foregroundColor(Palette.running)
+                    .padding(.horizontal, 4)
+                    .padding(.vertical, 1)
+                    .background(
+                        RoundedRectangle(cornerRadius: 3)
+                            .fill(Palette.running.opacity(0.12))
+                    )
+                Spacer()
+            }
+            .padding(.horizontal, 14)
+
+            VStack(spacing: 3) {
+                content()
+            }
+            .padding(.horizontal, 14)
+        }
+    }
+
+    private func relativeTime(_ date: Date) -> String {
+        let seconds = Int(Date().timeIntervalSince(date))
+        if seconds < 60 { return "\(seconds)s ago" }
+        if seconds < 3600 { return "\(seconds / 60)m ago" }
+        return "\(seconds / 3600)h ago"
+    }
+}

package/app/Sources/OmniSearchWindow.swift

@@ -0,0 +1,105 @@
+import AppKit
+import SwiftUI
+
+final class OmniSearchWindow {
+    static let shared = OmniSearchWindow()
+
+    private var panel: NSPanel?
+    private var keyMonitor: Any?
+    private var state: OmniSearchState?
+
+    var isVisible: Bool { panel?.isVisible ?? false }
+
+    func toggle() {
+        if isVisible {
+            dismiss()
+        } else {
+            show()
+        }
+    }
+
+    func show() {
+        if let p = panel, p.isVisible {
+            p.makeKeyAndOrderFront(nil)
+            NSApp.activate(ignoringOtherApps: true)
+            return
+        }
+
+        // Fresh state each time
+        let searchState = OmniSearchState()
+        state = searchState
+
+        let view = OmniSearchView(state: searchState) { [weak self] in
+            self?.dismiss()
+        }
+        .preferredColorScheme(.dark)
+
+        let hosting = NSHostingController(rootView: view)
+        hosting.preferredContentSize = NSSize(width: 520, height: 480)
+
+        let p = NSPanel(
+            contentRect: NSRect(x: 0, y: 0, width: 520, height: 480),
+            styleMask: [.titled, .closable, .resizable, .utilityWindow, .nonactivatingPanel],
+            backing: .buffered,
+            defer: false
+        )
+        p.contentViewController = hosting
+        p.title = "Omni Search"
+        p.titlebarAppearsTransparent = true
+        p.titleVisibility = .hidden
+        p.isMovableByWindowBackground = true
+        p.level = .floating
+        p.isOpaque = false
+        p.backgroundColor = NSColor(red: 0.11, green: 0.11, blue: 0.12, alpha: 1.0)
+        p.hasShadow = true
+        p.appearance = NSAppearance(named: .darkAqua)
+        p.collectionBehavior = [.canJoinAllSpaces, .fullScreenAuxiliary]
+        p.minSize = NSSize(width: 400, height: 300)
+        p.maxSize = NSSize(width: 700, height: 700)
+
+        // Center on screen
+        if let screen = NSScreen.main {
+            let visibleFrame = screen.visibleFrame
+            let x = visibleFrame.midX - 260
+            let y = visibleFrame.midY + 60  // slightly above center
+            p.setFrameOrigin(NSPoint(x: x, y: y))
+        }
+
+        p.makeKeyAndOrderFront(nil)
+        NSApp.activate(ignoringOtherApps: true)
+        panel = p
+
+        // Key monitor: Escape → dismiss, arrow keys → navigate, Enter → activate
+        keyMonitor = NSEvent.addLocalMonitorForEvents(matching: .keyDown) { [weak self] event in
+            guard self?.panel?.isKeyWindow == true else { return event }
+
+            switch event.keyCode {
+            case 53: // Escape
+                self?.dismiss()
+                return nil
+            case 125: // ↓
+                self?.state?.moveSelection(1)
+                return nil
+            case 126: // ↑
+                self?.state?.moveSelection(-1)
+                return nil
+            case 36: // Enter
+                self?.state?.activateSelected()
+                self?.dismiss()
+                return nil
+            default:
+                return event
+            }
+        }
+    }
+
+    func dismiss() {
+        panel?.orderOut(nil)
+        panel = nil
+        state = nil
+        if let monitor = keyMonitor {
+            NSEvent.removeMonitor(monitor)
+            keyMonitor = nil
+        }
+    }
+}

package/app/Sources/PaletteCommand.swift

@@ -364,9 +364,19 @@ enum CommandBuilder {
             }
         ))
 
+        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: "Screen Map",
+            title: "Window Map",
             subtitle: "Visual window editor",
             icon: "rectangle.3.group",
             category: .app,