@lattices/cli 0.4.14 → 0.5.0

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

@@ -1,259 +0,0 @@
-import AppKit
-
-enum Terminal: String, CaseIterable, Identifiable {
-    case terminal = "Terminal"
-    case iterm2 = "iTerm2"
-    case warp = "Warp"
-    case ghostty = "Ghostty"
-    case kitty = "Kitty"
-    case alacritty = "Alacritty"
-
-    var id: String { rawValue }
-
-    var bundleId: String {
-        switch self {
-        case .terminal:  return "com.apple.Terminal"
-        case .iterm2:    return "com.googlecode.iterm2"
-        case .warp:      return "dev.warp.Warp-Stable"
-        case .ghostty:   return "com.mitchellh.ghostty"
-        case .kitty:     return "net.kovidgoyal.kitty"
-        case .alacritty: return "org.alacritty"
-        }
-    }
-
-    var isInstalled: Bool {
-        NSWorkspace.shared.urlForApplication(withBundleIdentifier: bundleId) != nil
-    }
-
-    static var installed: [Terminal] {
-        allCases.filter(\.isInstalled)
-    }
-
-    /// Launch a command in this terminal
-    func launch(command: String, in directory: String) {
-        // Use single quotes for the shell command to avoid AppleScript escaping issues
-        let dir = directory.replacingOccurrences(of: "'", with: "'\\''")
-        let cmd = command.replacingOccurrences(of: "'", with: "'\\''")
-        let fullCmd = "cd '\(dir)' && \(cmd)"
-
-        switch self {
-        case .terminal:
-            runOsascript(
-                "tell application \"Terminal\"",
-                "activate",
-                "do script \"\(fullCmd)\"",
-                "end tell"
-            )
-
-        case .iterm2:
-            runOsascript(
-                "tell application \"iTerm2\"",
-                "activate",
-                "set newWindow to (create window with default profile)",
-                "tell current session of newWindow",
-                "write text \"\(fullCmd)\"",
-                "end tell",
-                "end tell"
-            )
-
-        case .warp:
-            let task = Process()
-            task.executableURL = URL(fileURLWithPath: "/usr/bin/open")
-            task.arguments = ["-a", "Warp", directory]
-            try? task.run()
-            task.waitUntilExit()
-            DispatchQueue.main.asyncAfter(deadline: .now() + 1.0) {
-                runOsascript(
-                    "tell application \"System Events\"",
-                    "tell process \"Warp\"",
-                    "keystroke \"\(cmd)\"",
-                    "keystroke return",
-                    "end tell",
-                    "end tell"
-                )
-            }
-
-        case .ghostty:
-            let task = Process()
-            task.executableURL = URL(fileURLWithPath: "/usr/bin/open")
-            task.arguments = ["-a", "Ghostty"]
-            task.environment = ["GHOSTTY_SHELL_COMMAND": fullCmd]
-            try? task.run()
-
-        case .kitty:
-            if let appUrl = NSWorkspace.shared.urlForApplication(withBundleIdentifier: bundleId) {
-                let kittyBin = appUrl.appendingPathComponent("Contents/MacOS/kitty").path
-                let task = Process()
-                task.executableURL = URL(fileURLWithPath: kittyBin)
-                task.arguments = ["--single-instance", "--directory", directory, "sh", "-c", command]
-                try? task.run()
-            }
-
-        case .alacritty:
-            if let appUrl = NSWorkspace.shared.urlForApplication(withBundleIdentifier: bundleId) {
-                let bin = appUrl.appendingPathComponent("Contents/MacOS/alacritty").path
-                let task = Process()
-                task.executableURL = URL(fileURLWithPath: bin)
-                task.arguments = ["--working-directory", directory, "-e", "sh", "-c", command]
-                try? task.run()
-            }
-        }
-    }
-
-    /// Launch a command in a new tab of the current terminal window
-    func launchTab(command: String, in directory: String, tabName: String? = nil) {
-        let dir = directory.replacingOccurrences(of: "'", with: "'\\''")
-        let cmd = command.replacingOccurrences(of: "'", with: "'\\''")
-        let fullCmd = "cd '\(dir)' && \(cmd)"
-
-        switch self {
-        case .iterm2:
-            var lines = [
-                "tell application \"iTerm2\"",
-                "activate",
-                "if (count of windows) = 0 then",
-                "  create window with default profile",
-                "else",
-                "  tell current window to create tab with default profile",
-                "end if",
-                "tell current session of current tab of current window",
-                "  write text \"\(fullCmd)\"",
-            ]
-            if let name = tabName {
-                let escaped = name.replacingOccurrences(of: "\"", with: "\\\"")
-                lines.append("  set name to \"\(escaped)\"")
-            }
-            lines.append("end tell")
-            lines.append("end tell")
-            runOsascriptLines(lines)
-
-        case .terminal:
-            var lines = [
-                "tell application \"Terminal\"",
-                "activate",
-                "if (count of windows) = 0 then",
-                "  do script \"\(fullCmd)\"",
-                "else",
-                "  do script \"\(fullCmd)\" in front window",
-                "end if",
-            ]
-            if let name = tabName {
-                let escaped = name.replacingOccurrences(of: "\"", with: "\\\"")
-                lines.append("set custom title of selected tab of front window to \"\(escaped)\"")
-            }
-            lines.append("end tell")
-            runOsascriptLines(lines)
-
-        default:
-            // Terminals without AppleScript tab support: fall back to new window
-            launch(command: command, in: directory)
-        }
-    }
-
-    /// Rename the current/frontmost tab in this terminal
-    func nameTab(_ name: String) {
-        let escaped = name.replacingOccurrences(of: "\"", with: "\\\"")
-        switch self {
-        case .iterm2:
-            runOsascript(
-                "tell application \"iTerm2\"",
-                "tell current session of current tab of current window",
-                "set name to \"\(escaped)\"",
-                "end tell",
-                "end tell"
-            )
-        case .terminal:
-            runOsascript(
-                "tell application \"Terminal\"",
-                "set custom title of selected tab of front window to \"\(escaped)\"",
-                "end tell"
-            )
-        default:
-            break
-        }
-    }
-
-    /// The tag we put in the terminal window title via tmux set-titles
-    static func windowTag(for session: String) -> String {
-        "[lattices:\(session)]"
-    }
-
-    /// Find and focus the existing terminal window by its [lattices:name] tag, or open a new attach
-    func focusOrAttach(session: String) {
-        let tag = Terminal.windowTag(for: session)
-
-        switch self {
-        case .terminal:
-            runOsascript(
-                "tell application \"Terminal\"",
-                "activate",
-                "set found to false",
-                "repeat with w in windows",
-                "  if name of w contains \"\(tag)\" then",
-                "    set index of w to 1",
-                "    set found to true",
-                "    exit repeat",
-                "  end if",
-                "end repeat",
-                "if not found then do script \"tmux attach -t \(session)\"",
-                "end tell"
-            )
-
-        case .iterm2:
-            // Search through all sessions in all tabs of all windows
-            runOsascript(
-                "tell application \"iTerm2\"",
-                "activate",
-                "set found to false",
-                "repeat with w in windows",
-                "  repeat with t in tabs of w",
-                "    repeat with s in sessions of t",
-                "      if name of s contains \"\(tag)\" then",
-                "        select w",
-                "        tell w to set current tab to t",
-                "        set found to true",
-                "        exit repeat",
-                "      end if",
-                "    end repeat",
-                "    if found then exit repeat",
-                "  end repeat",
-                "  if found then exit repeat",
-                "end repeat",
-                "if not found then",
-                "  if (count of windows) = 0 then",
-                "    create window with default profile",
-                "  else",
-                "    tell current window to create tab with default profile",
-                "  end if",
-                "  tell current session of current tab of current window",
-                "    write text \"tmux attach -t \(session)\"",
-                "  end tell",
-                "end if",
-                "end tell"
-            )
-
-        default:
-            // For terminals without good AppleScript support, just activate and attach
-            let task = Process()
-            task.executableURL = URL(fileURLWithPath: "/usr/bin/open")
-            task.arguments = ["-a", rawValue]
-            try? task.run()
-        }
-    }
-}
-
-/// Run an AppleScript by joining lines into a single -e script block
-private func runOsascript(_ lines: String...) {
-    runOsascriptLines(lines)
-}
-
-/// Run an AppleScript from an array of lines
-private func runOsascriptLines(_ lines: [String]) {
-    let script = lines.joined(separator: "\n")
-    let task = Process()
-    task.executableURL = URL(fileURLWithPath: "/usr/bin/osascript")
-    task.arguments = ["-e", script]
-    task.standardOutput = FileHandle.nullDevice
-    task.standardError = FileHandle.nullDevice
-    try? task.run()
-}

package/apps/mac/Sources/Core/Workspace/Terminal/TerminalQuery.swift

@@ -1,156 +0,0 @@
-import AppKit
-
-// MARK: - Data Model
-
-struct TerminalTab {
-    let app: Terminal
-    let windowIndex: Int
-    let tabIndex: Int
-    let tty: String           // normalized: "ttys003"
-    let isActiveTab: Bool
-    let title: String
-    let sessionId: String?    // iTerm2 unique ID only
-}
-
-// MARK: - Query
-
-enum TerminalQuery {
-
-    /// Normalize TTY strings: strip "/dev/" prefix if present.
-    /// iTerm2 returns "/dev/ttys003", Terminal.app and `ps` return "ttys003".
-    static func normalizeTTY(_ raw: String) -> String {
-        if raw.hasPrefix("/dev/") {
-            return String(raw.dropFirst(5))
-        }
-        return raw
-    }
-
-    /// Query all running terminal emulators for tab info.
-    /// Only queries apps that are currently running (won't auto-launch).
-    static func queryAll() -> [TerminalTab] {
-        var results: [TerminalTab] = []
-        if isAppRunning("iTerm2") {
-            results.append(contentsOf: queryITerm2())
-        }
-        if isAppRunning("Terminal") {
-            results.append(contentsOf: queryTerminalApp())
-        }
-        // Future: queryWarp(), queryGhostty(), etc.
-        return results
-    }
-
-    // MARK: - iTerm2
-
-    static func queryITerm2() -> [TerminalTab] {
-        let script = """
-        tell application "iTerm2"
-            set output to ""
-            set winIdx to 0
-            repeat with w in windows
-                set tabIdx to 0
-                repeat with t in tabs of w
-                    repeat with s in sessions of t
-                        set output to output & winIdx & "\t" & tabIdx & "\t" & (tty of s) & "\t" & (name of s) & "\t" & (unique ID of s) & linefeed
-                    end repeat
-                    set tabIdx to tabIdx + 1
-                end repeat
-                set winIdx to winIdx + 1
-            end repeat
-            return output
-        end tell
-        """
-
-        let raw = osascript(script)
-        guard !raw.isEmpty else { return [] }
-
-        var tabs: [TerminalTab] = []
-        for line in raw.split(separator: "\n", omittingEmptySubsequences: true) {
-            let cols = line.split(separator: "\t", maxSplits: 4, omittingEmptySubsequences: false)
-            guard cols.count >= 5 else { continue }
-
-            guard let winIdx = Int(cols[0]),
-                  let tabIdx = Int(cols[1]) else { continue }
-
-            let tty = normalizeTTY(String(cols[2]))
-            guard tty.hasPrefix("ttys") else { continue }
-
-            let title = String(cols[3])
-            let sessionId = String(cols[4])
-
-            tabs.append(TerminalTab(
-                app: .iterm2,
-                windowIndex: winIdx,
-                tabIndex: tabIdx,
-                tty: tty,
-                isActiveTab: false, // iTerm2 doesn't expose this easily in a single call
-                title: title,
-                sessionId: sessionId
-            ))
-        }
-        return tabs
-    }
-
-    // MARK: - Terminal.app
-
-    static func queryTerminalApp() -> [TerminalTab] {
-        let script = """
-        tell application "Terminal"
-            set output to ""
-            set winIdx to 0
-            repeat with w in windows
-                set selTab to selected tab of w
-                set tabIdx to 0
-                repeat with t in tabs of w
-                    set isSel to (t = selTab)
-                    set output to output & winIdx & "\t" & tabIdx & "\t" & (tty of t) & "\t" & (custom title of t) & "\t" & isSel & linefeed
-                    set tabIdx to tabIdx + 1
-                end repeat
-                set winIdx to winIdx + 1
-            end repeat
-            return output
-        end tell
-        """
-
-        let raw = osascript(script)
-        guard !raw.isEmpty else { return [] }
-
-        var tabs: [TerminalTab] = []
-        for line in raw.split(separator: "\n", omittingEmptySubsequences: true) {
-            let cols = line.split(separator: "\t", maxSplits: 4, omittingEmptySubsequences: false)
-            guard cols.count >= 5 else { continue }
-
-            guard let winIdx = Int(cols[0]),
-                  let tabIdx = Int(cols[1]) else { continue }
-
-            let tty = normalizeTTY(String(cols[2]))
-            guard tty.hasPrefix("ttys") else { continue }
-
-            let title = String(cols[3])
-            let isActive = String(cols[4]).lowercased() == "true"
-
-            tabs.append(TerminalTab(
-                app: .terminal,
-                windowIndex: winIdx,
-                tabIndex: tabIdx,
-                tty: tty,
-                isActiveTab: isActive,
-                title: title,
-                sessionId: nil
-            ))
-        }
-        return tabs
-    }
-
-    // MARK: - Helpers
-
-    /// Check if a named app is already running (prevents AppleScript from auto-launching it).
-    private static func isAppRunning(_ name: String) -> Bool {
-        NSWorkspace.shared.runningApplications.contains { $0.localizedName == name }
-    }
-
-    /// Run an AppleScript and capture stdout.
-    /// Uses ProcessQuery.shell to avoid Process.waitUntilExit() deadlocks on macOS 26.
-    private static func osascript(_ source: String) -> String {
-        ProcessQuery.shell(["/usr/bin/osascript", "-e", source])
-    }
-}

package/apps/mac/Sources/Core/Workspace/Terminal/TerminalSynthesizer.swift

@@ -1,200 +0,0 @@
-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/apps/mac/Sources/Core/Workspace/Tmux/TmuxModel.swift

@@ -1,60 +0,0 @@
-import Foundation
-
-final class TmuxModel: ObservableObject {
-    static let shared = TmuxModel()
-
-    @Published private(set) var sessions: [TmuxSession] = []
-    @Published private(set) var isAvailable: Bool = TmuxQuery.isAvailable
-    private var timer: Timer?
-
-    func start(interval: TimeInterval = 3.0) {
-        guard timer == nil else { return }
-
-        if !isAvailable {
-            DiagnosticLog.shared.warn("TmuxModel: tmux not found — session features disabled")
-            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
-    }
-}