@lattices/cli 0.3.0

package/app/Sources/TerminalSynthesizer.swift

@@ -0,0 +1,200 @@
+import Foundation
+
+// MARK: - Unified Output
+
+struct TerminalInstance {
+    // Join key
+    let tty: String
+
+    // Tab info (from AppleScript)
+    let app: Terminal?
+    let windowIndex: Int?
+    let tabIndex: Int?
+    let isActiveTab: Bool
+    let tabTitle: String?
+    let terminalSessionId: String?     // iTerm2 unique ID
+
+    // Process info (from ps)
+    let processes: [ProcessEntry]
+    let shellPid: Int?
+    let cwd: String?
+
+    // Tmux info
+    let tmuxSession: String?
+    let tmuxPaneId: String?
+
+    // Window info (from CGWindowList)
+    let windowId: UInt32?
+    let windowTitle: String?
+
+    // Computed
+    var hasClaude: Bool {
+        processes.contains { $0.comm == "claude" }
+    }
+
+    var displayName: String {
+        if let session = tmuxSession { return session }
+        if let title = tabTitle, !title.isEmpty { return title }
+        if let title = windowTitle, !title.isEmpty { return title }
+        return tty
+    }
+}
+
+// MARK: - Synthesizer
+
+enum TerminalSynthesizer {
+
+    /// Pure-function merge: joins 5 slices by TTY into unified TerminalInstances.
+    ///
+    /// - Parameters:
+    ///   - processTable: Full process table from ProcessQuery.snapshot()
+    ///   - interesting: Filtered interesting processes
+    ///   - tmuxSessions: Current tmux sessions with panes
+    ///   - terminalTabs: AppleScript-enumerated tabs
+    ///   - windows: CGWindowList entries
+    static func synthesize(
+        processTable: [Int: ProcessEntry],
+        interesting: [ProcessEntry],
+        tmuxSessions: [TmuxSession],
+        terminalTabs: [TerminalTab],
+        windows: [UInt32: WindowEntry]
+    ) -> [TerminalInstance] {
+
+        // 1. Single pass: index ALL processes by normalized TTY
+        //    This avoids O(TTYs × processes) re-scans later.
+        var allProcessesByTTY: [String: [ProcessEntry]] = [:]
+        for entry in processTable.values {
+            let tty = TerminalQuery.normalizeTTY(entry.tty)
+            guard tty != "??" else { continue }
+            allProcessesByTTY[tty, default: []].append(entry)
+        }
+
+        // 2. Group interesting processes by TTY (subset of above)
+        var interestingByTTY: [String: [ProcessEntry]] = [:]
+        for entry in interesting {
+            let tty = TerminalQuery.normalizeTTY(entry.tty)
+            guard tty != "??" else { continue }
+            interestingByTTY[tty, default: []].append(entry)
+        }
+
+        // 3. Build tmux pane → TTY lookup
+        var tmuxByTTY: [String: (session: String, paneId: String)] = [:]
+        for session in tmuxSessions {
+            for pane in session.panes {
+                if let entry = processTable[pane.pid] {
+                    let tty = TerminalQuery.normalizeTTY(entry.tty)
+                    if tty != "??" {
+                        tmuxByTTY[tty] = (session: session.name, paneId: pane.id)
+                    }
+                }
+            }
+        }
+
+        // 4. Index terminal tabs by TTY
+        var tabByTTY: [String: TerminalTab] = [:]
+        for tab in terminalTabs {
+            tabByTTY[tab.tty] = tab
+        }
+
+        // 5. Collect all known TTYs (union of all maps)
+        var allTTYs = Set(interestingByTTY.keys)
+        allTTYs.formUnion(tmuxByTTY.keys)
+        allTTYs.formUnion(tabByTTY.keys)
+
+        // 6. Build window lookup for positional matching
+        let windowsByApp = buildWindowsByApp(windows)
+
+        // 7. For each TTY, merge all slices
+        var instances: [TerminalInstance] = []
+        for tty in allTTYs {
+            let procs = interestingByTTY[tty] ?? []
+            let tab = tabByTTY[tty]
+            let tmux = tmuxByTTY[tty]
+
+            // Shell PID: process on this TTY whose parent is NOT on this TTY
+            let ttyProcs = allProcessesByTTY[tty] ?? []
+            let ttyPids = Set(ttyProcs.map(\.pid))
+            let shellPid = ttyProcs.first { !ttyPids.contains($0.ppid) }?.pid
+
+            // CWD: deepest interesting process's cwd, or shell's cwd
+            let cwd = procs.last(where: { $0.cwd != nil })?.cwd
+                ?? (shellPid.flatMap { processTable[$0]?.cwd })
+
+            // Window: try lattices tag match first, then positional
+            let windowMatch = resolveWindow(
+                tmuxSession: tmux?.session,
+                tab: tab,
+                windowsByApp: windowsByApp,
+                allWindows: windows
+            )
+
+            instances.append(TerminalInstance(
+                tty: tty,
+                app: tab?.app,
+                windowIndex: tab?.windowIndex,
+                tabIndex: tab?.tabIndex,
+                isActiveTab: tab?.isActiveTab ?? false,
+                tabTitle: tab?.title,
+                terminalSessionId: tab?.sessionId,
+                processes: procs,
+                shellPid: shellPid,
+                cwd: cwd,
+                tmuxSession: tmux?.session,
+                tmuxPaneId: tmux?.paneId,
+                windowId: windowMatch?.wid,
+                windowTitle: windowMatch?.title
+            ))
+        }
+
+        // 7. Sort: Claude first, active tabs first, then by TTY
+        instances.sort { a, b in
+            if a.hasClaude != b.hasClaude { return a.hasClaude }
+            if a.isActiveTab != b.isActiveTab { return a.isActiveTab }
+            return a.tty < b.tty
+        }
+
+        return instances
+    }
+
+    // MARK: - Private Helpers
+
+    /// Group windows by app name for positional matching.
+    private static func buildWindowsByApp(_ windows: [UInt32: WindowEntry]) -> [String: [WindowEntry]] {
+        var result: [String: [WindowEntry]] = [:]
+        for w in windows.values {
+            result[w.app, default: []].append(w)
+        }
+        // Sort each app's windows for consistent positional matching
+        for key in result.keys {
+            result[key]?.sort { $0.wid < $1.wid }
+        }
+        return result
+    }
+
+    /// Resolve a window for this TTY. Try lattices tag match first, then positional.
+    private static func resolveWindow(
+        tmuxSession: String?,
+        tab: TerminalTab?,
+        windowsByApp: [String: [WindowEntry]],
+        allWindows: [UInt32: WindowEntry]
+    ) -> WindowEntry? {
+        // Strategy 1: lattices session tag match
+        if let session = tmuxSession {
+            let tag = Terminal.windowTag(for: session)
+            if let match = allWindows.values.first(where: { $0.title.contains(tag) }) {
+                return match
+            }
+        }
+
+        // Strategy 2: positional match by app + window index
+        if let tab = tab {
+            let appName = tab.app.rawValue
+            if let appWindows = windowsByApp[appName],
+               tab.windowIndex < appWindows.count {
+                return appWindows[tab.windowIndex]
+            }
+        }
+
+        return nil
+    }
+}

package/app/Sources/Theme.swift

@@ -0,0 +1,163 @@
+import SwiftUI
+
+// MARK: - Colors
+
+enum Palette {
+    // Base surfaces — warm dark
+    static let bg         = Color(red: 0.11, green: 0.11, blue: 0.12)   // #1C1C1E
+    static let surface    = Color(red: 0.15, green: 0.15, blue: 0.16)   // Raised cards
+    static let surfaceHov = Color(red: 0.18, green: 0.18, blue: 0.19)   // Hovered cards
+    static let border     = Color.white.opacity(0.05)
+    static let borderLit  = Color.white.opacity(0.10)
+
+    // Text
+    static let text       = Color.white.opacity(0.92)
+    static let textDim    = Color.white.opacity(0.50)
+    static let textMuted  = Color.white.opacity(0.30)
+
+    // Functional accents
+    static let running  = Color(red: 0.20, green: 0.78, blue: 0.45)   // Green
+    static let detach   = Color(red: 0.96, green: 0.65, blue: 0.14)   // Amber
+    static let kill     = Color(red: 0.94, green: 0.30, blue: 0.35)   // Red
+    static let launch   = Color.white                                   // Clean white
+}
+
+// MARK: - Typography
+
+enum Typo {
+    private static let jetbrains = "JetBrains Mono"
+    private static let geist     = "GeistMono Nerd Font"
+    private static let gohu      = "GohuFontuni14 Nerd Font"
+
+    static func title(_ size: CGFloat = 15) -> Font {
+        .system(size: size, weight: .bold, design: .rounded)
+    }
+
+    static func heading(_ size: CGFloat = 13) -> Font {
+        .system(size: size, weight: .semibold, design: .rounded)
+    }
+
+    static func body(_ size: CGFloat = 12) -> Font {
+        .system(size: size, weight: .regular, design: .rounded)
+    }
+
+    static func caption(_ size: CGFloat = 10) -> Font {
+        .system(size: size, weight: .medium, design: .rounded)
+    }
+
+    static func mono(_ size: CGFloat = 11) -> Font {
+        .custom(jetbrains, size: size)
+    }
+
+    static func monoBold(_ size: CGFloat = 11) -> Font {
+        Font.custom(jetbrains, size: size).weight(.semibold)
+    }
+
+    static func geistMono(_ size: CGFloat = 11) -> Font {
+        .custom(geist, size: size)
+    }
+
+    static func geistMonoBold(_ size: CGFloat = 11) -> Font {
+        Font.custom(geist, size: size).weight(.medium)
+    }
+
+    static func pixel(_ size: CGFloat = 14) -> Font {
+        .custom(gohu, size: size)
+    }
+}
+
+// MARK: - Background
+
+struct PanelBackground: View {
+    var body: some View {
+        Palette.bg
+    }
+}
+
+// MARK: - Reusable modifiers
+
+struct GlassCard: ViewModifier {
+    var isHovered: Bool = false
+
+    func body(content: Content) -> some View {
+        content
+            .background(
+                RoundedRectangle(cornerRadius: 5)
+                    .fill(isHovered ? Palette.surfaceHov : Palette.surface)
+                    .overlay(
+                        RoundedRectangle(cornerRadius: 5)
+                            .strokeBorder(isHovered ? Palette.borderLit : Palette.border, lineWidth: 0.5)
+                    )
+            )
+    }
+}
+
+struct LiquidGlassCard: ViewModifier {
+    func body(content: Content) -> some View {
+        content
+            .background(
+                ZStack {
+                    // Base: translucent dark fill
+                    RoundedRectangle(cornerRadius: 10)
+                        .fill(Color.white.opacity(0.04))
+
+                    // Subtle gradient: brighter at top edge for "glass reflection"
+                    RoundedRectangle(cornerRadius: 10)
+                        .fill(
+                            LinearGradient(
+                                colors: [Color.white.opacity(0.06), Color.clear],
+                                startPoint: .top,
+                                endPoint: .center
+                            )
+                        )
+
+                    // Border: top-bright, bottom-dark for depth
+                    RoundedRectangle(cornerRadius: 10)
+                        .strokeBorder(
+                            LinearGradient(
+                                colors: [Color.white.opacity(0.12), Color.white.opacity(0.04)],
+                                startPoint: .top,
+                                endPoint: .bottom
+                            ),
+                            lineWidth: 0.5
+                        )
+                }
+            )
+            .shadow(color: Color.black.opacity(0.2), radius: 8, y: 4)
+    }
+}
+
+struct AngularButton: ViewModifier {
+    let color: Color
+    var filled: Bool = true
+
+    func body(content: Content) -> some View {
+        content
+            .font(Typo.monoBold(10))
+            .foregroundColor(filled ? Palette.bg : color)
+            .padding(.horizontal, 8)
+            .padding(.vertical, 4)
+            .background(
+                RoundedRectangle(cornerRadius: 3)
+                    .fill(filled ? color : color.opacity(0.10))
+            )
+            .overlay(
+                RoundedRectangle(cornerRadius: 3)
+                    .strokeBorder(filled ? Color.clear : color.opacity(0.25), lineWidth: 0.5)
+            )
+    }
+}
+
+extension View {
+    func glassCard(hovered: Bool = false) -> some View {
+        modifier(GlassCard(isHovered: hovered))
+    }
+
+    func liquidGlass() -> some View {
+        modifier(LiquidGlassCard())
+    }
+
+    func angularButton(_ color: Color, filled: Bool = true) -> some View {
+        modifier(AngularButton(color: color, filled: filled))
+    }
+}

package/app/Sources/TilePickerView.swift

@@ -0,0 +1,209 @@
+import SwiftUI
+
+struct TilePickerView: View {
+    let sessionName: String
+    let terminal: Terminal
+    let onSelect: (TilePosition) -> Void
+    let onGoToSpace: (Int) -> Void  // space ID
+    let onDismiss: () -> Void
+
+    @State private var hoveredTile: TilePosition?
+    @State private var hoveredSpace: Int?  // space ID
+    @State private var displaySpaces: [DisplaySpaces] = []
+    @State private var windowSpaceId: Int = 0
+    @State private var currentTile: TilePosition?
+
+    private let grid: [[TilePosition]] = [
+        [.topLeft, .topRight],
+        [.left, .right],
+        [.bottomLeft, .bottomRight],
+    ]
+
+    var body: some View {
+        VStack(spacing: 8) {
+            HStack {
+                Text("TILE WINDOW")
+                    .font(Typo.pixel(12))
+                    .foregroundColor(Palette.running)
+                Spacer()
+                Button(action: onDismiss) {
+                    Image(systemName: "xmark")
+                        .font(.system(size: 8, weight: .bold))
+                        .foregroundColor(Palette.textDim)
+                        .frame(width: 18, height: 18)
+                        .background(
+                            RoundedRectangle(cornerRadius: 3)
+                                .fill(Palette.surface)
+                        )
+                }
+                .buttonStyle(.plain)
+            }
+
+            // Tile grid
+            VStack(spacing: 3) {
+                ForEach(grid, id: \.first?.id) { row in
+                    HStack(spacing: 3) {
+                        ForEach(row) { tile in
+                            tileCell(tile)
+                        }
+                    }
+                }
+            }
+
+            HStack(spacing: 3) {
+                tileWideCell(.maximize)
+                tileWideCell(.center)
+            }
+
+            // Spaces per display — navigate to space
+            ForEach(displaySpaces, id: \.displayIndex) { display in
+                if display.spaces.count > 1 || displaySpaces.count > 1 {
+                    Rectangle()
+                        .fill(Palette.border)
+                        .frame(height: 0.5)
+                        .padding(.vertical, 2)
+
+                    HStack {
+                        Text(displaySpaces.count > 1
+                            ? "DISPLAY \(display.displayIndex + 1) SPACES"
+                            : "GO TO SPACE")
+                            .font(Typo.pixel(10))
+                            .foregroundColor(Palette.textMuted)
+                        Spacer()
+                        if windowSpaceId > 0 {
+                            let windowOnDisplay = display.spaces.contains { $0.id == windowSpaceId }
+                            if windowOnDisplay {
+                                Text("window here")
+                                    .font(Typo.mono(9))
+                                    .foregroundColor(Palette.running)
+                            }
+                        }
+                    }
+
+                    HStack(spacing: 3) {
+                        ForEach(display.spaces) { space in
+                            spaceCell(space: space)
+                        }
+                    }
+                }
+            }
+        }
+        .padding(12)
+        .background(
+            RoundedRectangle(cornerRadius: 6)
+                .fill(Palette.surface)
+                .overlay(
+                    RoundedRectangle(cornerRadius: 6)
+                        .strokeBorder(Palette.borderLit, lineWidth: 0.5)
+                )
+        )
+        .onAppear {
+            displaySpaces = WindowTiler.getDisplaySpaces()
+            // Find which space this session's window is on + current tile
+            if let info = WindowTiler.getWindowInfo(session: sessionName, terminal: terminal) {
+                if let spaceId = WindowTiler.getSpacesForWindow(info.wid).first {
+                    windowSpaceId = spaceId
+                }
+                currentTile = info.tilePosition
+            }
+        }
+    }
+
+    private func tileCell(_ tile: TilePosition) -> some View {
+        let isCurrent = currentTile == tile
+        let isHovered = hoveredTile == tile
+        return Button {
+            onSelect(tile)
+        } label: {
+            Image(systemName: tile.icon)
+                .font(.system(size: 14))
+                .foregroundColor(isHovered ? Palette.running : isCurrent ? Palette.running.opacity(0.8) : Palette.textDim)
+                .frame(maxWidth: .infinity)
+                .frame(height: 32)
+                .background(
+                    RoundedRectangle(cornerRadius: 4)
+                        .fill(isHovered ? Palette.running.opacity(0.1) : isCurrent ? Palette.running.opacity(0.06) : Palette.bg)
+                        .overlay(
+                            RoundedRectangle(cornerRadius: 4)
+                                .strokeBorder(
+                                    isHovered ? Palette.running.opacity(0.3) : isCurrent ? Palette.running.opacity(0.25) : Palette.border,
+                                    lineWidth: isCurrent ? 1 : 0.5
+                                )
+                        )
+                )
+        }
+        .buttonStyle(.plain)
+        .onHover { hoveredTile = $0 ? tile : nil }
+    }
+
+    private func tileWideCell(_ tile: TilePosition) -> some View {
+        let isCurrent = currentTile == tile
+        let isHovered = hoveredTile == tile
+        return Button {
+            onSelect(tile)
+        } label: {
+            HStack(spacing: 4) {
+                Image(systemName: tile.icon)
+                    .font(.system(size: 12))
+                Text(tile.label)
+                    .font(Typo.mono(10))
+            }
+            .foregroundColor(isHovered ? Palette.running : isCurrent ? Palette.running.opacity(0.8) : Palette.textDim)
+            .frame(maxWidth: .infinity)
+            .frame(height: 28)
+            .background(
+                RoundedRectangle(cornerRadius: 4)
+                    .fill(isHovered ? Palette.running.opacity(0.1) : isCurrent ? Palette.running.opacity(0.06) : Palette.bg)
+                    .overlay(
+                        RoundedRectangle(cornerRadius: 4)
+                            .strokeBorder(
+                                isHovered ? Palette.running.opacity(0.3) : isCurrent ? Palette.running.opacity(0.25) : Palette.border,
+                                lineWidth: isCurrent ? 1 : 0.5
+                            )
+                    )
+            )
+        }
+        .buttonStyle(.plain)
+        .onHover { hoveredTile = $0 ? tile : nil }
+    }
+
+    private func spaceCell(space: SpaceInfo) -> some View {
+        let hasWindow = space.id == windowSpaceId
+        return Button {
+            onGoToSpace(space.id)
+        } label: {
+            HStack(spacing: 4) {
+                Image(systemName: space.isCurrent ? "desktopcomputer" : hasWindow ? "macwindow" : "rectangle.on.rectangle")
+                    .font(.system(size: 10))
+                Text("\(space.index)")
+                    .font(Typo.monoBold(11))
+            }
+            .foregroundColor(
+                hoveredSpace == space.id ? Palette.running :
+                hasWindow ? Palette.running :
+                space.isCurrent ? Palette.text : Palette.textDim
+            )
+            .frame(maxWidth: .infinity)
+            .frame(height: 28)
+            .background(
+                RoundedRectangle(cornerRadius: 4)
+                    .fill(
+                        hoveredSpace == space.id ? Palette.running.opacity(0.1) :
+                        hasWindow ? Palette.running.opacity(0.05) :
+                        space.isCurrent ? Palette.bg.opacity(0.5) : Palette.bg
+                    )
+                    .overlay(
+                        RoundedRectangle(cornerRadius: 4)
+                            .strokeBorder(
+                                hoveredSpace == space.id ? Palette.running.opacity(0.3) :
+                                hasWindow ? Palette.running.opacity(0.3) :
+                                space.isCurrent ? Palette.borderLit : Palette.border,
+                                lineWidth: 0.5
+                            )
+                    )
+            )
+        }
+        .buttonStyle(.plain)
+        .onHover { hoveredSpace = $0 ? space.id : nil }
+    }
+}

package/app/Sources/TmuxModel.swift

@@ -0,0 +1,53 @@
+import Foundation
+
+final class TmuxModel: ObservableObject {
+    static let shared = TmuxModel()
+
+    @Published private(set) var sessions: [TmuxSession] = []
+    private var timer: Timer?
+
+    func start(interval: TimeInterval = 3.0) {
+        guard timer == nil else { return }
+        DiagnosticLog.shared.info("TmuxModel: starting (interval=\(interval)s)")
+        poll()
+        timer = Timer.scheduledTimer(withTimeInterval: interval, repeats: true) { [weak self] _ in
+            self?.poll()
+        }
+    }
+
+    func stop() {
+        timer?.invalidate()
+        timer = nil
+    }
+
+    func poll() {
+        let fresh = TmuxQuery.listSessions()
+        let changed = sessionsChanged(old: sessions, new: fresh)
+
+        DispatchQueue.main.async {
+            self.sessions = fresh
+        }
+
+        if changed {
+            EventBus.shared.post(.tmuxChanged(sessions: fresh))
+        }
+    }
+
+    func isRunning(_ name: String) -> Bool {
+        sessions.contains { $0.name == name }
+    }
+
+    private func sessionsChanged(old: [TmuxSession], new: [TmuxSession]) -> Bool {
+        guard old.count == new.count else { return true }
+        let oldNames = Set(old.map(\.name))
+        let newNames = Set(new.map(\.name))
+        if oldNames != newNames { return true }
+        // Check pane counts changed
+        for newSession in new {
+            guard let oldSession = old.first(where: { $0.name == newSession.name }) else { return true }
+            if oldSession.panes.count != newSession.panes.count { return true }
+            if oldSession.attached != newSession.attached { return true }
+        }
+        return false
+    }
+}