@lattices/cli 0.4.14 → 0.5.0

package/apps/mac/Sources/Core/Workspace/ProjectScanner.swift

@@ -1,141 +0,0 @@
-import Foundation
-
-class ProjectScanner: ObservableObject {
-    static let shared = ProjectScanner()
-
-    @Published var projects: [Project] = []
-
-    private var scanRoot: String
-
-    init(root: String? = nil) {
-        self.scanRoot = root ?? Preferences.shared.scanRoot
-    }
-
-    func updateRoot(_ root: String) {
-        self.scanRoot = root
-    }
-
-    private static let scanQueue = DispatchQueue(label: "com.lattices.project-scanner", qos: .userInitiated)
-    private var scanInFlight = false
-
-    func scan() {
-        guard !scanInFlight else { return }
-        scanInFlight = true
-        let root = scanRoot
-
-        Self.scanQueue.async { [weak self] in
-            guard let self else { return }
-            let diag = DiagnosticLog.shared
-
-            // Use find to locate all .lattices.json files — no manual directory walking
-            let tFind = diag.startTimed("ProjectScanner: find .lattices.json")
-            let task = Process()
-            task.executableURL = URL(fileURLWithPath: "/usr/bin/find")
-            task.arguments = [root, "-name", ".lattices.json", "-maxdepth", "3", "-not", "-path", "*/.git/*", "-not", "-path", "*/node_modules/*"]
-            let pipe = Pipe()
-            task.standardOutput = pipe
-            task.standardError = FileHandle.nullDevice
-            try? task.run()
-            task.waitUntilExit()
-            diag.finish(tFind)
-
-            let data = pipe.fileHandleForReading.readDataToEndOfFile()
-            let output = String(data: data, encoding: .utf8) ?? ""
-            let configPaths = output.split(separator: "\n").map(String.init).filter { !$0.isEmpty }
-
-            let tParse = diag.startTimed("ProjectScanner: parse \(configPaths.count) configs")
-            var found: [Project] = []
-
-            for configPath in configPaths.sorted() {
-                let projectPath = (configPath as NSString).deletingLastPathComponent
-                let name = (projectPath as NSString).lastPathComponent
-                let (devCmd, pm) = self.detectDevCommand(at: projectPath)
-                let paneInfo = self.readPaneInfo(at: configPath)
-
-                var project = Project(
-                    id: projectPath,
-                    path: projectPath,
-                    name: name,
-                    devCommand: devCmd,
-                    packageManager: pm,
-                    hasConfig: true,
-                    paneCount: paneInfo.count,
-                    paneNames: paneInfo.names,
-                    paneSummary: paneInfo.summary,
-                    isRunning: false
-                )
-                project.isRunning = self.isSessionRunning(project.sessionName)
-                found.append(project)
-            }
-            diag.finish(tParse)
-
-            diag.info("ProjectScanner: found \(found.count) projects (\(found.filter(\.isRunning).count) running)")
-            DispatchQueue.main.async {
-                self.projects = found
-                self.scanInFlight = false
-            }
-        }
-    }
-
-    func refreshStatus() {
-        for i in projects.indices {
-            projects[i].isRunning = isSessionRunning(projects[i].sessionName)
-        }
-    }
-
-    // MARK: - Detection
-
-    private func detectDevCommand(at path: String) -> (String?, String?) {
-        let pkgPath = (path as NSString).appendingPathComponent("package.json")
-        guard let data = FileManager.default.contents(atPath: pkgPath),
-              let json = try? JSONSerialization.jsonObject(with: data) as? [String: Any],
-              let scripts = json["scripts"] as? [String: String]
-        else { return (nil, nil) }
-
-        let has = { (f: String) in
-            FileManager.default.fileExists(atPath: (path as NSString).appendingPathComponent(f))
-        }
-
-        var pm = "npm"
-        if has("pnpm-lock.yaml") { pm = "pnpm" }
-        else if has("bun.lockb") || has("bun.lock") { pm = "bun" }
-        else if has("yarn.lock") { pm = "yarn" }
-
-        let run = pm == "npm" ? "npm run" : pm
-        if scripts["dev"] != nil { return ("\(run) dev", pm) }
-        if scripts["start"] != nil { return ("\(run) start", pm) }
-        if scripts["serve"] != nil { return ("\(run) serve", pm) }
-        if scripts["watch"] != nil { return ("\(run) watch", pm) }
-        return (nil, pm)
-    }
-
-    private func readPaneInfo(at configPath: String) -> (count: Int, names: [String], summary: String) {
-        guard let data = FileManager.default.contents(atPath: configPath),
-              let json = try? JSONSerialization.jsonObject(with: data) as? [String: Any],
-              let panes = json["panes"] as? [[String: Any]]
-        else { return (2, ["claude", "server"], "") }
-
-        let labels = panes.compactMap { pane -> String? in
-            if let name = pane["name"] as? String { return name }
-            if let cmd = pane["cmd"] as? String {
-                let parts = cmd.split(separator: " ")
-                return parts.first.map(String.init)
-            }
-            return nil
-        }
-        return (panes.count, labels, labels.joined(separator: " · "))
-    }
-
-    private static var tmuxPath: String { TmuxQuery.resolvedPath ?? "/opt/homebrew/bin/tmux" }
-
-    private func isSessionRunning(_ name: String) -> Bool {
-        let task = Process()
-        task.executableURL = URL(fileURLWithPath: Self.tmuxPath)
-        task.arguments = ["has-session", "-t", name]
-        task.standardOutput = FileHandle.nullDevice
-        task.standardError = FileHandle.nullDevice
-        try? task.run()
-        task.waitUntilExit()
-        return task.terminationStatus == 0
-    }
-}

package/apps/mac/Sources/Core/Workspace/SessionLayerStore.swift

@@ -1,285 +0,0 @@
-import AppKit
-
-// MARK: - WindowRef
-
-struct WindowRef: Codable, Identifiable {
-    let id: String
-
-    // ── Intent (stable, survives restarts) ──
-    var app: String
-    var contentHint: String?
-    var tile: String?
-    var display: Int?
-
-    // ── Runtime (ephemeral, filled when window is live) ──
-    var wid: UInt32?
-    var pid: Int32?
-    var title: String?
-    var frame: WindowFrame?
-
-    init(id: String = UUID().uuidString, app: String, contentHint: String? = nil,
-         tile: String? = nil, display: Int? = nil,
-         wid: UInt32? = nil, pid: Int32? = nil, title: String? = nil, frame: WindowFrame? = nil) {
-        self.id = id
-        self.app = app
-        self.contentHint = contentHint
-        self.tile = tile
-        self.display = display
-        self.wid = wid
-        self.pid = pid
-        self.title = title
-        self.frame = frame
-    }
-}
-
-// MARK: - SessionLayer
-
-struct SessionLayer: Identifiable, Codable {
-    let id: String
-    var name: String
-    var windows: [WindowRef]
-
-    init(id: String = UUID().uuidString, name: String, windows: [WindowRef] = []) {
-        self.id = id
-        self.name = name
-        self.windows = windows
-    }
-}
-
-// MARK: - SessionLayerStore
-
-final class SessionLayerStore: ObservableObject {
-    static let shared = SessionLayerStore()
-
-    @Published var layers: [SessionLayer] = []
-    @Published var activeIndex: Int = -1
-
-    private init() {
-        // Listen for window changes to reconcile stale refs
-        EventBus.shared.subscribe { [weak self] event in
-            if case .windowsChanged = event {
-                DispatchQueue.main.async {
-                    self?.reconcile()
-                }
-            }
-        }
-    }
-
-    // MARK: - CRUD
-
-    @discardableResult
-    func create(name: String, windows: [WindowRef] = []) -> SessionLayer {
-        let layer = SessionLayer(name: name, windows: windows)
-        layers.append(layer)
-        DiagnosticLog.shared.info("SessionLayerStore: created '\(name)' with \(windows.count) refs")
-        // If this is the first layer, activate it
-        if layers.count == 1 { activeIndex = 0 }
-        return layer
-    }
-
-    func delete(id: String) {
-        guard let idx = layers.firstIndex(where: { $0.id == id }) else { return }
-        // Clear layer tags for windows in this layer
-        for ref in layers[idx].windows {
-            if let wid = ref.wid {
-                DesktopModel.shared.removeLayerTag(wid: wid)
-            }
-        }
-        layers.remove(at: idx)
-        // Adjust activeIndex
-        if layers.isEmpty {
-            activeIndex = -1
-        } else if activeIndex >= layers.count {
-            activeIndex = layers.count - 1
-        }
-    }
-
-    func rename(id: String, name: String) {
-        guard let idx = layers.firstIndex(where: { $0.id == id }) else { return }
-        layers[idx].name = name
-    }
-
-    func clear() {
-        DesktopModel.shared.clearLayerTags()
-        layers.removeAll()
-        activeIndex = -1
-        LayerBezel.shared.invalidateCache()
-    }
-
-    func layerById(_ id: String) -> SessionLayer? {
-        layers.first { $0.id == id }
-    }
-
-    func layerByName(_ name: String) -> SessionLayer? {
-        layers.first { $0.name.localizedCaseInsensitiveCompare(name) == .orderedSame }
-    }
-
-    // MARK: - Window Management
-
-    func assign(ref: WindowRef, toLayerId id: String) {
-        guard let idx = layers.firstIndex(where: { $0.id == id }) else { return }
-        layers[idx].windows.append(ref)
-        if let wid = ref.wid {
-            DesktopModel.shared.assignLayer(wid: wid, layerId: layers[idx].name)
-        }
-    }
-
-    func assignByWid(_ wid: UInt32, toLayerId id: String) {
-        guard let idx = layers.firstIndex(where: { $0.id == id }) else { return }
-        guard let entry = DesktopModel.shared.windows[wid] else { return }
-        // Don't add duplicates
-        if layers[idx].windows.contains(where: { $0.wid == wid }) { return }
-        let ref = WindowRef(
-            app: entry.app,
-            contentHint: entry.title,
-            wid: entry.wid,
-            pid: entry.pid,
-            title: entry.title,
-            frame: entry.frame
-        )
-        layers[idx].windows.append(ref)
-        DesktopModel.shared.assignLayer(wid: wid, layerId: layers[idx].name)
-    }
-
-    func remove(refId: String, fromLayerId id: String) {
-        guard let idx = layers.firstIndex(where: { $0.id == id }) else { return }
-        if let refIdx = layers[idx].windows.firstIndex(where: { $0.id == refId }) {
-            if let wid = layers[idx].windows[refIdx].wid {
-                DesktopModel.shared.removeLayerTag(wid: wid)
-            }
-            layers[idx].windows.remove(at: refIdx)
-        }
-    }
-
-    func tagFrontmostWindow() {
-        guard let frontApp = NSWorkspace.shared.frontmostApplication,
-              frontApp.bundleIdentifier != "com.arach.lattices" else { return }
-
-        let pid = frontApp.processIdentifier
-        // Find the frontmost window for this app
-        guard let entry = DesktopModel.shared.windows.values
-            .first(where: { $0.pid == pid }) else { return }
-
-        // If no layers exist, create one
-        if layers.isEmpty {
-            create(name: "Layer 1")
-        }
-
-        // If no active layer, use first
-        let targetIndex = activeIndex >= 0 ? activeIndex : 0
-        guard targetIndex < layers.count else { return }
-
-        let layerId = layers[targetIndex].id
-        assignByWid(entry.wid, toLayerId: layerId)
-        DiagnosticLog.shared.info("SessionLayerStore: tagged \(entry.app) '\(entry.title)' → '\(layers[targetIndex].name)'")
-
-        // Show bezel feedback
-        let allNames = layers.map(\.name)
-        LayerBezel.shared.show(
-            label: layers[targetIndex].name,
-            index: targetIndex,
-            total: layers.count,
-            allLabels: allNames
-        )
-    }
-
-    // MARK: - Switching
-
-    func switchTo(index: Int) {
-        guard index >= 0, index < layers.count else { return }
-        activeIndex = index
-
-        DesktopModel.shared.poll()
-
-        var resolved: [(wid: UInt32, pid: Int32)] = []
-        for i in layers[index].windows.indices {
-            if let r = resolve(&layers[index].windows[i]) {
-                resolved.append(r)
-            }
-        }
-
-        if !resolved.isEmpty {
-            WindowTiler.raiseWindowsAndReactivate(windows: resolved)
-        }
-
-        let allNames = layers.map(\.name)
-        LayerBezel.shared.show(
-            label: layers[index].name,
-            index: index,
-            total: layers.count,
-            allLabels: allNames
-        )
-
-        DiagnosticLog.shared.info("SessionLayerStore: switched to '\(layers[index].name)' (\(resolved.count)/\(layers[index].windows.count) resolved)")
-    }
-
-    func cycleNext() {
-        guard !layers.isEmpty else { return }
-        let next = (activeIndex + 1) % layers.count
-        switchTo(index: next)
-    }
-
-    func cyclePrev() {
-        guard !layers.isEmpty else { return }
-        let prev = activeIndex <= 0 ? layers.count - 1 : activeIndex - 1
-        switchTo(index: prev)
-    }
-
-    // MARK: - Resolution
-
-    private func resolve(_ ref: inout WindowRef) -> (wid: UInt32, pid: Int32)? {
-        // 1. Fast path: wid still valid
-        if let wid = ref.wid, let entry = DesktopModel.shared.windows[wid] {
-            ref.pid = entry.pid
-            ref.title = entry.title
-            ref.frame = entry.frame
-            return (wid, entry.pid)
-        }
-
-        // 2. Re-resolve by app + contentHint
-        if let entry = DesktopModel.shared.windowForApp(app: ref.app, title: ref.contentHint) {
-            ref.wid = entry.wid
-            ref.pid = entry.pid
-            ref.title = entry.title
-            ref.frame = entry.frame
-            DesktopModel.shared.assignLayer(wid: entry.wid, layerId: layerNameForRef(ref))
-            return (entry.wid, entry.pid)
-        }
-
-        // 3. Window not found — dormant
-        ref.wid = nil
-        ref.pid = nil
-        ref.title = nil
-        ref.frame = nil
-        return nil
-    }
-
-    private func layerNameForRef(_ ref: WindowRef) -> String {
-        for layer in layers {
-            if layer.windows.contains(where: { $0.id == ref.id }) {
-                return layer.name
-            }
-        }
-        return ""
-    }
-
-    // MARK: - Reconciliation
-
-    func reconcile() {
-        let desktop = DesktopModel.shared
-        for layerIdx in layers.indices {
-            for refIdx in layers[layerIdx].windows.indices {
-                let ref = layers[layerIdx].windows[refIdx]
-                guard let wid = ref.wid else { continue }
-                if desktop.windows[wid] == nil {
-                    // Window gone — clear runtime, keep intent
-                    layers[layerIdx].windows[refIdx].wid = nil
-                    layers[layerIdx].windows[refIdx].pid = nil
-                    layers[layerIdx].windows[refIdx].title = nil
-                    layers[layerIdx].windows[refIdx].frame = nil
-                    desktop.removeLayerTag(wid: wid)
-                }
-            }
-        }
-    }
-}

package/apps/mac/Sources/Core/Workspace/SessionManager.swift

@@ -1,75 +0,0 @@
-import AppKit
-
-enum SessionManager {
-    private static let latticesPath = "/opt/homebrew/bin/lattices"
-    private static var tmuxPath: String { TmuxQuery.resolvedPath ?? "/opt/homebrew/bin/tmux" }
-
-    /// Launch or reattach — if session is running, find and focus the existing window
-    static func launch(project: Project) {
-        let terminal = Preferences.shared.terminal
-        if project.isRunning {
-            if let window = DesktopModel.shared.windowForSession(project.sessionName) {
-                DesktopModel.shared.markInteraction(wid: window.wid)
-            }
-            terminal.focusOrAttach(session: project.sessionName)
-        } else {
-            terminal.launch(command: "\(latticesPath) start", in: project.path)
-        }
-    }
-
-    /// Detach all clients from a tmux session (keeps it running)
-    static func detach(project: Project) {
-        detachByName(project.sessionName)
-    }
-
-    /// Detach all clients by session name string (for layer switching without a Project object)
-    static func detachByName(_ sessionName: String) {
-        let task = Process()
-        task.executableURL = URL(fileURLWithPath: tmuxPath)
-        task.arguments = ["detach-client", "-s", sessionName]
-        task.standardOutput = FileHandle.nullDevice
-        task.standardError = FileHandle.nullDevice
-        try? task.run()
-        task.waitUntilExit()
-    }
-
-    /// Kill a tmux session
-    static func kill(project: Project) {
-        killByName(project.sessionName)
-    }
-
-    /// Kill a tmux session by name string (for orphan sessions without a Project object)
-    static func killByName(_ sessionName: String) {
-        let task = Process()
-        task.executableURL = URL(fileURLWithPath: tmuxPath)
-        task.arguments = ["kill-session", "-t", sessionName]
-        task.standardOutput = FileHandle.nullDevice
-        task.standardError = FileHandle.nullDevice
-        try? task.run()
-        task.waitUntilExit()
-    }
-
-    /// Reconcile session state to match declared config (recreate missing panes)
-    static func sync(project: Project) {
-        let task = Process()
-        task.executableURL = URL(fileURLWithPath: latticesPath)
-        task.arguments = ["sync"]
-        task.currentDirectoryURL = URL(fileURLWithPath: project.path)
-        task.standardOutput = FileHandle.nullDevice
-        task.standardError = FileHandle.nullDevice
-        try? task.run()
-        task.waitUntilExit()
-    }
-
-    /// Restart a specific pane's process (kill + re-run declared command)
-    static func restart(project: Project, paneName: String? = nil) {
-        let task = Process()
-        task.executableURL = URL(fileURLWithPath: latticesPath)
-        task.arguments = paneName != nil ? ["restart", paneName!] : ["restart"]
-        task.currentDirectoryURL = URL(fileURLWithPath: project.path)
-        task.standardOutput = FileHandle.nullDevice
-        task.standardError = FileHandle.nullDevice
-        try? task.run()
-        task.waitUntilExit()
-    }
-}