@lattices/cli 0.4.14 → 0.6.0

package/apps/mac/Sources/Core/Overlays/HUD/HUDState.swift

@@ -1,367 +0,0 @@
-import Combine
-import CoreGraphics
-import Foundation
-
-// MARK: - HUDItem
-
-enum HUDItem: Identifiable, Equatable {
-    case project(Project)
-    case window(WindowEntry)
-
-    var id: String {
-        switch self {
-        case .project(let p): return "project-\(p.id)"
-        case .window(let w):  return "window-\(w.wid)"
-        }
-    }
-
-    var displayName: String {
-        switch self {
-        case .project(let p): return p.name
-        case .window(let w):  return w.title
-        }
-    }
-
-    var appName: String? {
-        switch self {
-        case .project: return nil
-        case .window(let w): return w.app
-        }
-    }
-
-    static func == (lhs: HUDItem, rhs: HUDItem) -> Bool {
-        lhs.id == rhs.id
-    }
-}
-
-// MARK: - Focus target
-
-enum HUDFocus: Equatable {
-    case search       // typing into the left bar search field
-    case list         // navigating the left bar item list
-    case inspector    // tabbed over to the right bar
-}
-
-// MARK: - HUDState
-
-final class HUDState: ObservableObject {
-    private static let leftSidebarWidthKey = "hud.leftSidebarWidth"
-    private static let defaultLeftSidebarWidth: CGFloat = 320
-    private static let minLeftSidebarWidth: CGFloat = 260
-    private static let maxLeftSidebarWidth: CGFloat = 420
-
-    @Published var selectedItem: HUDItem?
-    @Published var pinnedItem: HUDItem?
-    @Published var hoveredPreviewItem: HUDItem?
-    @Published var feedbackMessage: String?
-    @Published var query: String = ""
-    @Published var selectedIndex: Int = 0
-    @Published var focus: HUDFocus = .search
-    @Published var voiceActive: Bool = false
-    @Published var expandedSections: Set<Int> = [2]
-    @Published var leftSidebarWidth: CGFloat = {
-        let saved = UserDefaults.standard.double(forKey: HUDState.leftSidebarWidthKey)
-        if saved > 0 {
-            return min(max(CGFloat(saved), HUDState.minLeftSidebarWidth), HUDState.maxLeftSidebarWidth)
-        }
-        return HUDState.defaultLeftSidebarWidth
-    }()
-
-    /// Multi-select for tiling — set of item IDs
-    @Published var selectedItems: Set<String> = []
-
-    enum MinimapMode: Equatable { case hidden, docked, expanded }
-    @Published var minimapMode: MinimapMode = .docked
-
-    // MARK: - Tile mode
-
-    @Published var tileMode: Bool = false
-
-    /// Snapshot of window positions taken when entering tile mode
-    struct WindowSnapshot {
-        let wid: UInt32
-        let pid: Int32
-        let frame: CGRect
-    }
-    var tileSnapshot: [WindowSnapshot] = []
-    var tiledWindows: Set<UInt32> = []
-
-    /// Pre-computed grid layout — calculated on HUD show, applied instantly on T press
-    var precomputedGrid: [(wid: UInt32, pid: Int32, frame: CGRect)] = []
-
-    /// Snapshot of the flat item list — set by HUDLeftBar so key handler can index into it
-    var flatItems: [HUDItem] = []
-
-    var hoverPreviewAnchorScreenY: CGFloat?
-    var previewInteractionActive: Bool = false
-
-    /// Section offsets for number-key jumping (1=Projects, 2=Terminals, 3=Chrome, 4=Claude)
-    var sectionOffsets: [Int: Int] = [:]
-
-    private var selectionAnchorID: String?
-    private var touchedSections: Set<Int> = []
-    private var feedbackClearWorkItem: DispatchWorkItem?
-
-    var leftSidebarWidthRange: ClosedRange<CGFloat> {
-        Self.minLeftSidebarWidth...Self.maxLeftSidebarWidth
-    }
-
-    func setLeftSidebarWidth(_ width: CGFloat) {
-        let clamped = min(max(width, Self.minLeftSidebarWidth), Self.maxLeftSidebarWidth)
-        guard abs(clamped - leftSidebarWidth) > 0.5 else { return }
-        leftSidebarWidth = clamped
-        UserDefaults.standard.set(Double(clamped), forKey: Self.leftSidebarWidthKey)
-    }
-
-    func isSectionExpanded(_ key: Int) -> Bool {
-        expandedSections.contains(key)
-    }
-
-    func toggleSection(_ key: Int) {
-        if expandedSections.contains(key) {
-            expandedSections.remove(key)
-        } else {
-            expandedSections.insert(key)
-        }
-        touchedSections.insert(key)
-    }
-
-    func resetSectionDefaults(hasRunningProjects: Bool) {
-        expandedSections = [2]
-        if hasRunningProjects {
-            expandedSections.insert(1)
-        }
-        touchedSections = []
-    }
-
-    func syncAutoSectionDefaults(hasRunningProjects: Bool) {
-        if !touchedSections.contains(2) {
-            expandedSections.insert(2)
-        }
-        if !touchedSections.contains(1) {
-            if hasRunningProjects {
-                expandedSections.insert(1)
-            } else {
-                expandedSections.remove(1)
-            }
-        }
-    }
-
-    var effectiveSelectionIDs: Set<String> {
-        if selectedItems.isEmpty {
-            if let selectedItem {
-                return [selectedItem.id]
-            }
-            return []
-        }
-
-        var ids = selectedItems
-        if let selectedItem {
-            ids.insert(selectedItem.id)
-        }
-        return ids
-    }
-
-    var multiSelectionCount: Int {
-        let count = effectiveSelectionIDs.count
-        return count > 1 ? count : 0
-    }
-
-    var transientPreviewItem: HUDItem? {
-        if let hoveredPreviewItem {
-            return hoveredPreviewItem
-        }
-        if pinnedItem == nil && focus == .list {
-            return selectedItem
-        }
-        return nil
-    }
-
-    var inspectorCandidateItem: HUDItem? {
-        if let pinnedItem {
-            return pinnedItem
-        }
-        if let hoveredPreviewItem {
-            return hoveredPreviewItem
-        }
-        return selectedItem
-    }
-
-    func clearMultiSelection() {
-        selectedItems = []
-        if let selectedItem {
-            selectionAnchorID = selectedItem.id
-        } else {
-            selectionAnchorID = nil
-        }
-    }
-
-    func selectSingle(_ item: HUDItem, index: Int) {
-        selectedItem = item
-        selectedIndex = index
-        selectedItems = []
-        selectionAnchorID = item.id
-    }
-
-    func showFeedback(_ message: String, autoClearAfter delay: TimeInterval = 0.9) {
-        feedbackClearWorkItem?.cancel()
-        feedbackMessage = message
-
-        let clearWorkItem = DispatchWorkItem { [weak self] in
-            guard self?.feedbackMessage == message else { return }
-            self?.feedbackMessage = nil
-        }
-        feedbackClearWorkItem = clearWorkItem
-        DispatchQueue.main.asyncAfter(deadline: .now() + delay, execute: clearWorkItem)
-    }
-
-    func pinInspector(_ item: HUDItem, source: String = "selection") {
-        let timed = AppFeedback.shared.beginTimed(
-            "HUD inspect (\(source))",
-            state: self,
-            feedback: "Inspecting \(item.displayName)"
-        )
-        if let idx = flatItems.firstIndex(of: item) {
-            selectedIndex = idx
-        }
-        selectedItem = item
-        pinnedItem = item
-        hoveredPreviewItem = nil
-        selectedItems = []
-        selectionAnchorID = item.id
-        focus = .inspector
-        DispatchQueue.main.async {
-            AppFeedback.shared.finish(timed)
-        }
-    }
-
-    func pinInspectorCandidate(source: String = "preview") {
-        guard let item = inspectorCandidateItem else { return }
-        pinInspector(item, source: source)
-    }
-
-    func toggleSelection(_ item: HUDItem, index: Int, in items: [HUDItem]) {
-        let anchorID = selectionAnchorID ?? selectedItem?.id ?? item.id
-
-        if selectedItems.isEmpty, let current = selectedItem {
-            selectedItems = [current.id]
-        }
-
-        if selectedItems.contains(item.id) {
-            selectedItems.remove(item.id)
-        } else {
-            selectedItems.insert(item.id)
-        }
-
-        if selectedItems.isEmpty {
-            selectSingle(item, index: index)
-            return
-        }
-
-        if selectedItems.count == 1,
-           let remainingID = selectedItems.first,
-           let remainingIndex = items.firstIndex(where: { $0.id == remainingID }),
-           let remainingItem = items[safe: remainingIndex] {
-            selectSingle(remainingItem, index: remainingIndex)
-            return
-        }
-
-        selectedItem = item
-        selectedIndex = index
-        selectionAnchorID = anchorID
-    }
-
-    func selectRange(to item: HUDItem, index: Int, in items: [HUDItem]) {
-        guard !items.isEmpty else { return }
-
-        let anchorID = selectionAnchorID ?? selectedItem?.id ?? item.id
-        guard let anchorIndex = items.firstIndex(where: { $0.id == anchorID }) else {
-            selectSingle(item, index: index)
-            return
-        }
-
-        let lower = min(anchorIndex, index)
-        let upper = max(anchorIndex, index)
-        let ids = Set(items[lower...upper].map(\.id))
-
-        selectedItem = item
-        selectedIndex = index
-        selectedItems = ids.count > 1 ? ids : []
-        selectionAnchorID = anchorID
-    }
-
-    func moveSelection(by delta: Int, extend: Bool) {
-        let items = flatItems
-        guard !items.isEmpty else { return }
-
-        let currentIndex: Int
-        if let selectedItem,
-           let idx = items.firstIndex(of: selectedItem) {
-            currentIndex = idx
-        } else {
-            currentIndex = max(0, min(items.count - 1, selectedIndex))
-        }
-
-        let nextIndex = max(0, min(items.count - 1, currentIndex + delta))
-        guard let nextItem = items[safe: nextIndex] else { return }
-
-        if extend {
-            selectRange(to: nextItem, index: nextIndex, in: items)
-        } else {
-            selectSingle(nextItem, index: nextIndex)
-        }
-    }
-
-    func reconcileSelection(with items: [HUDItem]) {
-        let validIDs = Set(items.map(\.id))
-
-        selectedItems = selectedItems.intersection(validIDs)
-        if let selectedItem, !validIDs.contains(selectedItem.id) {
-            self.selectedItem = nil
-        }
-        if let pinnedItem, !validIDs.contains(pinnedItem.id) {
-            self.pinnedItem = nil
-        }
-        if let hoveredPreviewItem, !validIDs.contains(hoveredPreviewItem.id) {
-            self.hoveredPreviewItem = nil
-        }
-        if let selectionAnchorID, !validIDs.contains(selectionAnchorID) {
-            self.selectionAnchorID = selectedItem?.id
-        }
-
-        guard !items.isEmpty else {
-            selectedItem = nil
-            pinnedItem = nil
-            hoveredPreviewItem = nil
-            selectedIndex = 0
-            selectedItems = []
-            selectionAnchorID = nil
-            return
-        }
-
-        if selectedItem == nil {
-            let clampedIndex = max(0, min(items.count - 1, selectedIndex))
-            if let fallback = items[safe: clampedIndex] {
-                selectedItem = fallback
-                selectedIndex = clampedIndex
-                if selectionAnchorID == nil {
-                    selectionAnchorID = fallback.id
-                }
-            }
-            return
-        }
-
-        if let selectedItem,
-           let itemIndex = items.firstIndex(of: selectedItem) {
-            selectedIndex = itemIndex
-        } else {
-            selectedIndex = max(0, min(items.count - 1, selectedIndex))
-        }
-    }
-}
-
-private extension Array {
-    subscript(safe index: Int) -> Element? {
-        indices.contains(index) ? self[index] : nil
-    }
-}

package/apps/mac/Sources/Core/Overlays/HUD/HUDTopBar.swift

@@ -1,243 +0,0 @@
-import SwiftUI
-
-// MARK: - HUDTopBar
-
-struct HUDTopBar: View {
-    @ObservedObject var state: HUDState
-    @ObservedObject private var handsOff = HandsOffSession.shared
-    @ObservedObject private var workspace = WorkspaceManager.shared
-    var onDismiss: () -> Void
-
-    var body: some View {
-        HStack(spacing: 0) {
-            // Logo
-            logo
-                .padding(.leading, 16)
-
-            // Voice status (when active)
-            if state.voiceActive {
-                voiceStatus
-                    .padding(.leading, 12)
-            }
-
-            Spacer()
-
-            // Layer strip (Hyprland-style)
-            if let layers = workspace.config?.layers, !layers.isEmpty {
-                layerStrip(layers)
-                    .padding(.trailing, 12)
-            }
-
-            // Quick actions
-            HStack(spacing: 6) {
-                quickAction(icon: "rectangle.3.group", label: "Map", shortcut: "⌃⌥⇧⌘1") {
-                    onDismiss()
-                    DispatchQueue.main.asyncAfter(deadline: .now() + 0.1) {
-                        ScreenMapWindowController.shared.toggle()
-                    }
-                }
-
-                quickAction(icon: "magnifyingglass", label: "Search", shortcut: "⌃⌥⇧⌘5") {
-                    onDismiss()
-                    DispatchQueue.main.asyncAfter(deadline: .now() + 0.1) {
-                        OmniSearchWindow.shared.toggle()
-                    }
-                }
-
-                quickAction(icon: "text.justify.left", label: "Palette", shortcut: "⇧⌘M") {
-                    onDismiss()
-                    DispatchQueue.main.asyncAfter(deadline: .now() + 0.1) {
-                        CommandPaletteWindow.shared.toggle()
-                    }
-                }
-            }
-            .padding(.trailing, 16)
-        }
-        .frame(maxWidth: .infinity)
-        .frame(height: 44)
-        .background(Palette.bg)
-    }
-
-    // MARK: - Layer strip (Hyprland-style workspace bar)
-
-    private func layerStrip(_ layers: [Layer]) -> some View {
-        HStack(spacing: 3) {
-            ForEach(Array(layers.enumerated()), id: \.element.id) { idx, layer in
-                let isActive = idx == workspace.activeLayerIndex
-
-                Button {
-                    workspace.focusLayer(index: idx)
-                } label: {
-                    HStack(spacing: 4) {
-                        Circle()
-                            .fill(isActive ? Palette.running : Palette.textMuted.opacity(0.3))
-                            .frame(width: 5, height: 5)
-
-                        Text(layer.label)
-                            .font(Typo.monoBold(9))
-                            .foregroundColor(isActive ? Palette.text : Palette.textMuted)
-                            .lineLimit(1)
-                    }
-                    .padding(.horizontal, 8)
-                    .padding(.vertical, 4)
-                    .background(
-                        RoundedRectangle(cornerRadius: 4)
-                            .fill(isActive ? Palette.surfaceHov : Palette.surface.opacity(0.5))
-                            .overlay(
-                                RoundedRectangle(cornerRadius: 4)
-                                    .strokeBorder(isActive ? Palette.running.opacity(0.4) : Palette.border.opacity(0.5), lineWidth: 0.5)
-                            )
-                    )
-                }
-                .buttonStyle(.plain)
-            }
-        }
-    }
-
-    // MARK: - Logo
-
-    private var logo: some View {
-        HStack(spacing: 7) {
-            latticesGrid
-            Text("lattices")
-                .font(Typo.monoBold(11))
-                .foregroundColor(Palette.textMuted.opacity(0.6))
-        }
-    }
-
-    /// 3×3 grid matching the menu bar icon — L-shape bright, rest dim
-    private var latticesGrid: some View {
-        let cellSize: CGFloat = 3
-        let gap: CGFloat = 1.5
-        let solidCells: Set<Int> = [0, 3, 6, 7, 8]
-
-        return Canvas { ctx, _ in
-            for row in 0..<3 {
-                for col in 0..<3 {
-                    let idx = row * 3 + col
-                    let x = CGFloat(col) * (cellSize + gap)
-                    let y = CGFloat(row) * (cellSize + gap)
-                    let rect = CGRect(x: x, y: y, width: cellSize, height: cellSize)
-                    let opacity: Double = solidCells.contains(idx) ? 0.5 : 0.15
-                    ctx.fill(
-                        Path(roundedRect: rect, cornerRadius: 0.5),
-                        with: .color(.white.opacity(opacity))
-                    )
-                }
-            }
-        }
-        .frame(width: 3 * 3 + 2 * 1.5, height: 3 * 3 + 2 * 1.5)
-    }
-
-    // MARK: - Voice status
-
-    private var voiceStatus: some View {
-        HStack(spacing: 8) {
-            // Pulsing dot + state
-            Circle()
-                .fill(voiceColor)
-                .frame(width: 6, height: 6)
-                .overlay(
-                    Circle()
-                        .stroke(voiceColor.opacity(0.4), lineWidth: 1)
-                        .scaleEffect(handsOff.state == .listening ? 2.0 : 1.0)
-                        .opacity(handsOff.state == .listening ? 0 : 1)
-                        .animation(
-                            handsOff.state == .listening
-                                ? .easeOut(duration: 1.0).repeatForever(autoreverses: false)
-                                : .default,
-                            value: handsOff.state
-                        )
-                )
-
-            Text(voiceLabel)
-                .font(Typo.monoBold(9))
-                .foregroundColor(voiceColor)
-
-            // Dialogue: last user message → last response
-            if let transcript = handsOff.lastTranscript {
-                Rectangle().fill(Palette.border).frame(width: 0.5, height: 16)
-
-                // What user said
-                HStack(spacing: 3) {
-                    Text("you")
-                        .font(Typo.monoBold(8))
-                        .foregroundColor(Palette.textMuted)
-                    Text(transcript)
-                        .font(Typo.mono(9))
-                        .foregroundColor(Palette.text)
-                        .lineLimit(1)
-                }
-                .frame(maxWidth: 300, alignment: .leading)
-            }
-
-            if let response = handsOff.lastResponse {
-                // What Lattices said back
-                HStack(spacing: 3) {
-                    Text("→")
-                        .font(Typo.mono(9))
-                        .foregroundColor(Palette.running)
-                    Text(response)
-                        .font(Typo.mono(9))
-                        .foregroundColor(Palette.textMuted)
-                        .lineLimit(1)
-                }
-                .frame(maxWidth: 350, alignment: .leading)
-            }
-        }
-        .padding(.horizontal, 10)
-        .padding(.vertical, 4)
-        .background(
-            RoundedRectangle(cornerRadius: 5)
-                .fill(voiceColor.opacity(0.08))
-                .overlay(
-                    RoundedRectangle(cornerRadius: 5)
-                        .strokeBorder(voiceColor.opacity(0.2), lineWidth: 0.5)
-                )
-        )
-    }
-
-    private var voiceColor: Color {
-        switch handsOff.state {
-        case .idle:       return Palette.running
-        case .connecting: return Palette.detach
-        case .listening:  return Palette.running
-        case .thinking:   return Palette.detach
-        }
-    }
-
-    private var voiceLabel: String {
-        switch handsOff.state {
-        case .idle:       return "ready"
-        case .connecting: return "connecting"
-        case .listening:  return "listening"
-        case .thinking:   return "thinking"
-        }
-    }
-
-    // MARK: - Quick action button
-
-    private func quickAction(icon: String, label: String, shortcut: String, action: @escaping () -> Void) -> some View {
-        Button(action: action) {
-            HStack(spacing: 5) {
-                Image(systemName: icon)
-                    .font(.system(size: 10))
-                Text(label)
-                    .font(Typo.mono(10))
-            }
-            .foregroundColor(Palette.textMuted)
-            .padding(.horizontal, 10)
-            .padding(.vertical, 5)
-            .background(
-                RoundedRectangle(cornerRadius: 5)
-                    .fill(Palette.surface)
-                    .overlay(
-                        RoundedRectangle(cornerRadius: 5)
-                            .strokeBorder(Palette.border, lineWidth: 0.5)
-                    )
-            )
-        }
-        .buttonStyle(.plain)
-        .help("\(label) (\(shortcut))")
-    }
-}