@lattices/cli 0.4.14 → 0.6.0

package/apps/mac/Sources/AppShell/AppShellView.swift

@@ -1,171 +0,0 @@
-import SwiftUI
-
-// MARK: - Navigation Pages
-
-enum AppPage: String, CaseIterable {
-    case home
-    case screenMap
-    case desktopInventory
-    case pi
-    case settings
-    case companionSettings
-    case docs
-
-    var label: String {
-        switch self {
-        case .home:             return "Home"
-        case .screenMap:        return "Layout"
-        case .desktopInventory: return "Desktop Inventory"
-        case .pi:               return "Assistant"
-        case .settings:         return "Settings"
-        case .companionSettings:return "Settings"
-        case .docs:             return "Docs"
-        }
-    }
-
-    var icon: String {
-        switch self {
-        case .home:             return "house"
-        case .screenMap:        return "rectangle.3.group"
-        case .desktopInventory: return "macwindow.on.rectangle"
-        case .pi:               return "bubble.left.and.bubble.right"
-        case .settings:         return "gearshape"
-        case .companionSettings:return "ipad.and.iphone"
-        case .docs:             return "book"
-        }
-    }
-
-    /// Pages shown as primary tabs in the unified window
-    static var primaryTabs: [AppPage] { [.home, .screenMap, .desktopInventory, .pi] }
-}
-
-// MARK: - App Shell View
-
-struct AppShellView: View {
-    @ObservedObject var controller: ScreenMapController
-    @ObservedObject var windowController = ScreenMapWindowController.shared
-    @StateObject private var commandState = CommandModeState()
-
-    var body: some View {
-        VStack(spacing: 0) {
-            // Tab bar (only on primary pages)
-            if AppPage.primaryTabs.contains(windowController.activePage) {
-                tabBar
-                Rectangle().fill(Palette.border).frame(height: 0.5)
-            }
-
-            contentArea
-        }
-        .background(Palette.bg)
-        .onAppear {
-            commandState.onDismiss = { windowController.activePage = .home }
-            syncPageState(windowController.activePage)
-        }
-        .onChange(of: windowController.activePage) { page in
-            syncPageState(page)
-            clearRelevantDismissals(for: page)
-        }
-    }
-
-    /// Entering a feature page clears its capability snooze — the user is
-    /// telling us they want this to work, so the banner can resurface.
-    private func clearRelevantDismissals(for page: AppPage) {
-        let prefs = Preferences.shared
-        switch page {
-        case .screenMap:
-            prefs.clearDismissal(Capability.windowControl.rawValue)
-        case .desktopInventory:
-            prefs.clearDismissal(Capability.screenSearch.rawValue)
-        default:
-            break
-        }
-    }
-
-    // MARK: - Tab Bar
-
-    private var tabBar: some View {
-        HStack(spacing: 0) {
-            ForEach(AppPage.primaryTabs, id: \.rawValue) { tab in
-                tabButton(tab)
-            }
-
-            Spacer()
-        }
-        .padding(.horizontal, 12)
-        .padding(.top, 8)
-        .padding(.bottom, 4)
-    }
-
-    private func tabButton(_ tab: AppPage) -> some View {
-        let isActive = windowController.activePage == tab
-
-        return Button {
-            windowController.activePage = tab
-            if tab == .screenMap { controller.enter() }
-            if tab == .desktopInventory { commandState.enter() }
-        } label: {
-            HStack(spacing: 5) {
-                Image(systemName: tab.icon)
-                    .font(.system(size: 10))
-                Text(tab.label)
-                    .font(Typo.monoBold(11))
-            }
-            .foregroundColor(isActive ? Palette.text : Palette.textMuted)
-            .padding(.horizontal, 12)
-            .padding(.vertical, 6)
-            .contentShape(Rectangle())
-            .background(
-                RoundedRectangle(cornerRadius: 6)
-                    .fill(isActive ? Palette.surfaceHov : Color.clear)
-            )
-        }
-        .buttonStyle(.plain)
-    }
-
-    // MARK: - Content Area
-
-    @ViewBuilder
-    private var contentArea: some View {
-        switch windowController.activePage {
-        case .home:
-            HomeDashboardView(onNavigate: { page in
-                windowController.activePage = page
-                if page == .screenMap { controller.enter() }
-                if page == .desktopInventory { commandState.enter() }
-            })
-        case .screenMap:
-            ScreenMapView(controller: controller, onNavigate: { page in
-                windowController.activePage = page
-            })
-        case .desktopInventory:
-            CommandModeView(state: commandState, presentation: .embedded)
-        case .pi:
-            PiWorkspaceView()
-        case .settings:
-            SettingsContentView(
-                prefs: Preferences.shared,
-                scanner: ProjectScanner.shared,
-                onBack: { windowController.activePage = .screenMap; controller.enter() }
-            )
-        case .companionSettings:
-            SettingsContentView(
-                page: .companionSettings,
-                prefs: Preferences.shared,
-                scanner: ProjectScanner.shared,
-                onBack: { windowController.activePage = .screenMap; controller.enter() }
-            )
-        case .docs:
-            SettingsContentView(
-                page: .docs,
-                prefs: Preferences.shared,
-                scanner: ProjectScanner.shared,
-                onBack: { windowController.activePage = .screenMap; controller.enter() }
-            )
-        }
-    }
-
-    private func syncPageState(_ page: AppPage) {
-        if page == .screenMap { controller.enter() }
-        if page == .desktopInventory { commandState.enter() }
-    }
-}

package/apps/mac/Sources/AppShell/AppUpdater.swift

@@ -1,305 +0,0 @@
-import AppKit
-import Combine
-import Foundation
-import SwiftUI
-
-struct LatticesUpdateInfo: Equatable {
-    let version: String
-    let downloadURL: URL
-    let releaseNotes: String
-    let publishedAt: Date
-    let htmlURL: URL
-}
-
-@MainActor
-final class AppUpdater: ObservableObject {
-    static let shared = AppUpdater()
-
-    @Published private(set) var isUpdating = false
-    @Published private(set) var statusMessage: String?
-    @Published private(set) var availableUpdate: LatticesUpdateInfo?
-    @Published private(set) var isChecking = false
-    @Published private(set) var lastChecked: Date?
-    @Published private(set) var lastError: String?
-
-    @AppStorage("appUpdater.autoCheck") var autoCheckEnabled = true
-    @AppStorage("appUpdater.lastCheckTime") private var lastCheckTimeInterval: Double = 0
-    @AppStorage("appUpdater.skippedVersion") private var skippedVersion = ""
-
-    private let checkInterval: TimeInterval = 24 * 60 * 60
-
-    private init() {}
-
-    var currentVersion: String { LatticesRuntime.appVersion }
-    var currentDisplayVersion: String { LatticesRuntime.appDisplayVersion }
-
-    var canUpdate: Bool {
-        LatticesRuntime.bunPath != nil && LatticesRuntime.appHelperScriptPath != nil
-    }
-
-    var unavailableReason: String? {
-        if LatticesRuntime.bunPath == nil {
-            return "Install Bun to enable in-app updates."
-        }
-        if LatticesRuntime.appHelperScriptPath == nil {
-            return "Launch Lattices via `lattices app` so the updater can find the CLI bundle."
-        }
-        return nil
-    }
-
-    func checkIfNeeded() async {
-        guard autoCheckEnabled else { return }
-
-        let now = Date()
-        let lastCheck = Date(timeIntervalSince1970: lastCheckTimeInterval)
-        if now.timeIntervalSince(lastCheck) < checkInterval { return }
-
-        await check()
-    }
-
-    func check() async {
-        guard !isChecking else { return }
-
-        isChecking = true
-        lastError = nil
-
-        defer {
-            isChecking = false
-            lastChecked = Date()
-            lastCheckTimeInterval = Date().timeIntervalSince1970
-        }
-
-        do {
-            let release = try await fetchLatestRelease()
-            guard let update = parseRelease(release), isNewerVersion(update.version) else {
-                availableUpdate = nil
-                return
-            }
-
-            if update.version == skippedVersion {
-                availableUpdate = nil
-                return
-            }
-
-            availableUpdate = update
-        } catch UpdateCheckError.noRelease {
-            availableUpdate = nil
-        } catch {
-            lastError = error.localizedDescription
-        }
-    }
-
-    func skipCurrentUpdate() {
-        guard let update = availableUpdate else { return }
-        skippedVersion = update.version
-        availableUpdate = nil
-    }
-
-    func viewCurrentRelease() {
-        if let update = availableUpdate {
-            NSWorkspace.shared.open(update.htmlURL)
-        } else if let url = URL(string: "https://github.com/arach/lattices/releases/latest") {
-            NSWorkspace.shared.open(url)
-        }
-    }
-
-    func promptForUpdate() {
-        guard canUpdate else {
-            presentAlert(
-                title: "Update Unavailable",
-                message: unavailableReason ?? "Lattices could not locate its updater."
-            )
-            return
-        }
-
-        guard availableUpdate != nil else {
-            Task {
-                await check()
-                if availableUpdate != nil {
-                    presentUpdateConfirmation()
-                } else if let error = lastError {
-                    presentAlert(
-                        title: "Could Not Check for Updates",
-                        message: error
-                    )
-                } else {
-                    presentAlert(
-                        title: "Lattices Is Up to Date",
-                        message: "You’re running \(currentDisplayVersion), which is the latest available build for this install."
-                    )
-                }
-            }
-            return
-        }
-
-        presentUpdateConfirmation()
-    }
-
-    private func presentUpdateConfirmation() {
-        let alert = NSAlert()
-        alert.alertStyle = .informational
-        if let update = availableUpdate {
-            alert.messageText = "Update Lattices?"
-            alert.informativeText = """
-            Current version: \(currentDisplayVersion)
-            New version: \(update.version)
-
-            Lattices will download the signed release, quit briefly, replace the app, and relaunch when the update is ready.
-            """
-        } else {
-            alert.messageText = "Check and update Lattices?"
-            alert.informativeText = """
-            Current version: \(currentDisplayVersion)
-            New version: latest published release
-
-            Lattices will download the signed release, quit briefly, replace the app, and relaunch when the update is ready.
-            """
-        }
-        alert.addButton(withTitle: availableUpdate == nil ? "Check & Update" : "Update")
-        alert.addButton(withTitle: "Cancel")
-
-        guard alert.runModal() == .alertFirstButtonReturn else { return }
-        startDetachedUpdate()
-    }
-
-    private func startDetachedUpdate() {
-        guard !isUpdating else { return }
-        guard let bunPath = LatticesRuntime.bunPath,
-              let scriptPath = LatticesRuntime.appHelperScriptPath else {
-            presentAlert(
-                title: "Update Unavailable",
-                message: unavailableReason ?? "Lattices could not locate its updater."
-            )
-            return
-        }
-
-        let proc = Process()
-        proc.executableURL = URL(fileURLWithPath: bunPath)
-        proc.arguments = [scriptPath, "update", "--detach", "--launch"]
-        if let cliRoot = LatticesRuntime.cliRoot {
-            proc.currentDirectoryURL = URL(fileURLWithPath: cliRoot)
-        }
-
-        var env = ProcessInfo.processInfo.environment
-        env.removeValue(forKey: "CLAUDECODE")
-        proc.environment = env
-
-        do {
-            try proc.run()
-            isUpdating = true
-            if let update = availableUpdate {
-                statusMessage = "Preparing Lattices \(update.version). The app will relaunch when the update is ready."
-            } else {
-                statusMessage = "Preparing the latest Lattices release. The app will relaunch when the update is ready."
-            }
-        } catch {
-            presentAlert(
-                title: "Update Failed",
-                message: "Lattices could not start the updater.\n\n\(error.localizedDescription)"
-            )
-        }
-    }
-
-    private func presentAlert(title: String, message: String) {
-        let alert = NSAlert()
-        alert.alertStyle = .warning
-        alert.messageText = title
-        alert.informativeText = message
-        alert.addButton(withTitle: "OK")
-        alert.runModal()
-    }
-
-    private func fetchLatestRelease() async throws -> GitHubRelease {
-        let url = URL(string: "https://api.github.com/repos/arach/lattices/releases/latest")!
-        var request = URLRequest(url: url)
-        request.setValue("application/vnd.github+json", forHTTPHeaderField: "Accept")
-        request.setValue("Lattices/\(currentVersion)", forHTTPHeaderField: "User-Agent")
-
-        let (data, response) = try await URLSession.shared.data(for: request)
-        guard let http = response as? HTTPURLResponse else {
-            throw UpdateCheckError.invalidResponse
-        }
-
-        switch http.statusCode {
-        case 200:
-            let decoder = JSONDecoder()
-            decoder.keyDecodingStrategy = .convertFromSnakeCase
-            decoder.dateDecodingStrategy = .iso8601
-            return try decoder.decode(GitHubRelease.self, from: data)
-        case 404:
-            throw UpdateCheckError.noRelease
-        case 403:
-            throw UpdateCheckError.rateLimited
-        default:
-            throw UpdateCheckError.httpError(http.statusCode)
-        }
-    }
-
-    private func parseRelease(_ release: GitHubRelease) -> LatticesUpdateInfo? {
-        guard !release.draft, !release.prerelease else { return nil }
-
-        let asset = release.assets.first { asset in
-            asset.name == "Lattices.dmg" ||
-            (asset.name.hasPrefix("Lattices") && asset.name.hasSuffix(".dmg"))
-        }
-
-        guard let asset,
-              let downloadURL = URL(string: asset.browserDownloadUrl),
-              let htmlURL = URL(string: release.htmlUrl) else {
-            return nil
-        }
-
-        let version = release.tagName.hasPrefix("v")
-            ? String(release.tagName.dropFirst())
-            : release.tagName
-
-        return LatticesUpdateInfo(
-            version: version,
-            downloadURL: downloadURL,
-            releaseNotes: release.body ?? "",
-            publishedAt: release.publishedAt,
-            htmlURL: htmlURL
-        )
-    }
-
-    private func isNewerVersion(_ remoteVersion: String) -> Bool {
-        guard currentVersion != "unknown" else { return false }
-        return remoteVersion.compare(currentVersion, options: .numeric) == .orderedDescending
-    }
-}
-
-private struct GitHubRelease: Decodable {
-    let tagName: String
-    let name: String
-    let body: String?
-    let htmlUrl: String
-    let publishedAt: Date
-    let assets: [GitHubAsset]
-    let prerelease: Bool
-    let draft: Bool
-}
-
-private struct GitHubAsset: Decodable {
-    let name: String
-    let browserDownloadUrl: String
-}
-
-private enum UpdateCheckError: LocalizedError {
-    case invalidResponse
-    case noRelease
-    case rateLimited
-    case httpError(Int)
-
-    var errorDescription: String? {
-        switch self {
-        case .invalidResponse:
-            return "Invalid response from GitHub."
-        case .noRelease:
-            return "No published release found."
-        case .rateLimited:
-            return "GitHub rate limited the update check."
-        case .httpError(let code):
-            return "GitHub returned HTTP \(code)."
-        }
-    }
-}

package/apps/mac/Sources/AppShell/CliActionLauncher.swift

@@ -1,50 +0,0 @@
-import AppKit
-
-enum CliActionLauncher {
-    private static var defaultDirectory: String {
-        let root = Preferences.shared.scanRoot
-        return root.isEmpty ? NSHomeDirectory() : root
-    }
-
-    private static func chooseProjectDirectory(message: String, prompt: String) -> String? {
-        let panel = NSOpenPanel()
-        panel.message = message
-        panel.prompt = prompt
-        panel.canChooseFiles = false
-        panel.canChooseDirectories = true
-        panel.allowsMultipleSelection = false
-        panel.directoryURL = URL(fileURLWithPath: defaultDirectory)
-        return panel.runModal() == .OK ? panel.url?.path : nil
-    }
-
-    static func initializeProjectInTerminal() {
-        guard let directory = chooseProjectDirectory(
-            message: "Choose a project folder to initialize with Lattices.",
-            prompt: "Initialize"
-        ) else { return }
-
-        Preferences.shared.terminal.launch(
-            command: "lattices init && lattices start",
-            in: directory
-        )
-    }
-
-    static func launchProjectInTerminal() {
-        guard let directory = chooseProjectDirectory(
-            message: "Choose a project folder to launch with Lattices.",
-            prompt: "Launch"
-        ) else { return }
-
-        Preferences.shared.terminal.launch(
-            command: "lattices start",
-            in: directory
-        )
-    }
-
-    static func installTmuxInTerminal() {
-        Preferences.shared.terminal.launch(
-            command: "brew install tmux",
-            in: defaultDirectory
-        )
-    }
-}

package/apps/mac/Sources/AppShell/HomeDashboardView.swift

@@ -1,133 +0,0 @@
-import SwiftUI
-
-struct HomeDashboardView: View {
-    var onNavigate: ((AppPage) -> Void)? = nil
-
-    @ObservedObject private var scanner = ProjectScanner.shared
-    @ObservedObject private var piSession = PiChatSession.shared
-
-    var body: some View {
-        VStack(spacing: 0) {
-            hero
-
-            Rectangle()
-                .fill(Palette.border)
-                .frame(height: 0.5)
-
-            MainView(scanner: scanner, layout: .embedded)
-        }
-        .background(Palette.bg)
-        .onAppear {
-            piSession.refreshBinaryAvailability()
-        }
-    }
-
-    private var hero: some View {
-        VStack(alignment: .leading, spacing: 18) {
-            HStack(alignment: .top) {
-                VStack(alignment: .leading, spacing: 8) {
-                    Text("Lattices Home")
-                        .font(Typo.heading(18))
-                        .foregroundColor(Palette.text)
-
-                    Text("Workspace status, project launch, layout, search, and chat in one place.")
-                        .font(Typo.mono(11))
-                        .foregroundColor(Palette.textDim)
-                        .fixedSize(horizontal: false, vertical: true)
-                }
-
-                Spacer()
-            }
-
-            HStack(spacing: 10) {
-                homeActionCard(
-                    title: "Layout",
-                    subtitle: "Arrange windows",
-                    icon: "rectangle.3.group",
-                    tint: Palette.running
-                ) {
-                    onNavigate?(.screenMap)
-                }
-
-                homeActionCard(
-                    title: "Search",
-                    subtitle: "Find workspace context",
-                    icon: "magnifyingglass",
-                    tint: Palette.detach
-                ) {
-                    onNavigate?(.desktopInventory)
-                }
-
-                homeActionCard(
-                    title: "Chat",
-                    subtitle: piSession.hasPiBinary
-                        ? (piSession.needsProviderSetup || piSession.isAuthenticating
-                            ? piSession.setupStatusSummary
-                            : "Standalone conversation surface")
-                        : "Install Pi to enable the assistant",
-                    icon: "bubble.left.and.bubble.right",
-                    tint: piSession.hasPiBinary ? Palette.text : Palette.kill
-                ) {
-                    onNavigate?(.pi)
-                }
-            }
-        }
-        .padding(.horizontal, 16)
-        .padding(.vertical, 16)
-        .background(
-            LinearGradient(
-                colors: [
-                    Palette.running.opacity(0.08),
-                    Color.black.opacity(0.18),
-                ],
-                startPoint: .topLeading,
-                endPoint: .bottomTrailing
-            )
-        )
-    }
-
-    private func homeActionCard(
-        title: String,
-        subtitle: String,
-        icon: String,
-        tint: Color,
-        action: @escaping () -> Void
-    ) -> some View {
-        Button(action: action) {
-            VStack(alignment: .leading, spacing: 10) {
-                HStack {
-                    Image(systemName: icon)
-                        .font(.system(size: 12, weight: .semibold))
-                        .foregroundColor(tint)
-
-                    Spacer()
-
-                    Circle()
-                        .fill(tint.opacity(0.85))
-                        .frame(width: 6, height: 6)
-                }
-
-                Text(title)
-                    .font(Typo.monoBold(12))
-                    .foregroundColor(Palette.text)
-
-                Text(subtitle)
-                    .font(Typo.mono(10))
-                    .foregroundColor(Palette.textMuted)
-                    .multilineTextAlignment(.leading)
-                    .fixedSize(horizontal: false, vertical: true)
-            }
-            .frame(maxWidth: .infinity, alignment: .leading)
-            .padding(12)
-            .background(
-                RoundedRectangle(cornerRadius: 8)
-                    .fill(Palette.surface.opacity(0.7))
-                    .overlay(
-                        RoundedRectangle(cornerRadius: 8)
-                            .strokeBorder(tint.opacity(0.18), lineWidth: 0.5)
-                    )
-            )
-        }
-        .buttonStyle(.plain)
-    }
-}