@arach/lattices 0.2.0 → 0.6.1

package/app/Sources/Preferences.swift

@@ -1,92 +0,0 @@
-import Foundation
-
-enum InteractionMode: String {
-    case learning = "learning"
-    case auto = "auto"
-}
-
-class Preferences: ObservableObject {
-    static let shared = Preferences()
-
-    @Published var terminal: Terminal {
-        didSet { UserDefaults.standard.set(terminal.rawValue, forKey: "terminal") }
-    }
-
-    @Published var scanRoot: String {
-        didSet { UserDefaults.standard.set(scanRoot, forKey: "scanRoot") }
-    }
-
-    @Published var mode: InteractionMode {
-        didSet { UserDefaults.standard.set(mode.rawValue, forKey: "mode") }
-    }
-
-    // MARK: - Search & OCR
-
-    @Published var ocrEnabled: Bool {
-        didSet { UserDefaults.standard.set(!ocrEnabled, forKey: "ocr.disabled") }
-    }
-
-    @Published var ocrQuickInterval: Double {
-        didSet { UserDefaults.standard.set(ocrQuickInterval, forKey: "ocr.interval") }
-    }
-
-    @Published var ocrDeepInterval: Double {
-        didSet { UserDefaults.standard.set(ocrDeepInterval, forKey: "ocr.deepInterval") }
-    }
-
-    @Published var ocrQuickLimit: Int {
-        didSet { UserDefaults.standard.set(ocrQuickLimit, forKey: "ocr.quickLimit") }
-    }
-
-    @Published var ocrDeepLimit: Int {
-        didSet { UserDefaults.standard.set(ocrDeepLimit, forKey: "ocr.deepLimit") }
-    }
-
-    @Published var ocrAccuracy: String {
-        didSet { UserDefaults.standard.set(ocrAccuracy, forKey: "ocr.accuracy") }
-    }
-
-    init() {
-        if let saved = UserDefaults.standard.string(forKey: "terminal"),
-           let t = Terminal(rawValue: saved), t.isInstalled {
-            self.terminal = t
-        } else {
-            self.terminal = Terminal.installed.first ?? .terminal
-        }
-
-        let savedRoot = UserDefaults.standard.string(forKey: "scanRoot") ?? ""
-        if savedRoot.isEmpty {
-            // Auto-detect a reasonable default
-            let home = NSHomeDirectory()
-            let candidates = ["\(home)/dev", "\(home)/Developer", "\(home)/projects", "\(home)/src"]
-            self.scanRoot = candidates.first { FileManager.default.fileExists(atPath: $0) } ?? ""
-        } else {
-            self.scanRoot = savedRoot
-        }
-
-        if let saved = UserDefaults.standard.string(forKey: "mode"),
-           let m = InteractionMode(rawValue: saved) {
-            self.mode = m
-        } else {
-            self.mode = .learning
-        }
-
-        // Search & OCR
-        self.ocrEnabled = !UserDefaults.standard.bool(forKey: "ocr.disabled")
-
-        let savedInterval = UserDefaults.standard.double(forKey: "ocr.interval")
-        self.ocrQuickInterval = savedInterval > 0 ? savedInterval : 60
-
-        let savedDeep = UserDefaults.standard.double(forKey: "ocr.deepInterval")
-        self.ocrDeepInterval = savedDeep > 0 ? savedDeep : 7200
-
-        let savedQL = UserDefaults.standard.integer(forKey: "ocr.quickLimit")
-        self.ocrQuickLimit = savedQL > 0 ? savedQL : 5
-
-        let savedDL = UserDefaults.standard.integer(forKey: "ocr.deepLimit")
-        self.ocrDeepLimit = savedDL > 0 ? savedDL : 15
-
-        let savedAcc = UserDefaults.standard.string(forKey: "ocr.accuracy") ?? "accurate"
-        self.ocrAccuracy = savedAcc
-    }
-}

package/app/Sources/ProcessModel.swift

@@ -1,199 +0,0 @@
-import Foundation
-
-final class ProcessModel: ObservableObject {
-    static let shared = ProcessModel()
-
-    @Published private(set) var processTable: [Int: ProcessEntry] = [:]
-    @Published private(set) var childrenMap: [Int: [Int]] = [:]       // ppid → [child pids]
-    @Published private(set) var interesting: [ProcessEntry] = []
-
-    private var timer: DispatchSourceTimer?
-    private var lastInterestingPids: Set<Int> = []
-
-    // Terminal tab cache — refreshed lazily when terminals are queried
-    private var cachedTerminalTabs: [TerminalTab] = []
-    private var lastTabQueryTime: Date = .distantPast
-    private static let tabCacheTTL: TimeInterval = 300.0  // 5 minutes
-
-    /// Background queue for process polling — avoids blocking the main thread
-    /// with posix_spawn calls (waitUntilExit deadlocks on macOS 26 main run loop).
-    private let pollQueue = DispatchQueue(label: "lattices.process-poll", qos: .userInitiated)
-
-    func start(interval: TimeInterval = 5.0) {
-        guard timer == nil else { return }
-        DiagnosticLog.shared.info("ProcessModel: starting (interval=\(interval)s)")
-
-        let source = DispatchSource.makeTimerSource(queue: pollQueue)
-        source.schedule(deadline: .now(), repeating: interval)
-        source.setEventHandler { [weak self] in
-            self?.poll()
-        }
-        source.resume()
-        timer = source
-    }
-
-    func stop() {
-        timer?.cancel()
-        timer = nil
-    }
-
-    // MARK: - Query Methods
-
-    /// All interesting developer processes with CWDs resolved.
-    func interestingProcesses() -> [ProcessEntry] {
-        interesting
-    }
-
-    /// BFS walk all descendants of a given PID.
-    func descendants(of pid: Int) -> [ProcessEntry] {
-        var result: [ProcessEntry] = []
-        var queue = childrenMap[pid] ?? []
-        var visited: Set<Int> = [pid]
-
-        while !queue.isEmpty {
-            let childPid = queue.removeFirst()
-            guard !visited.contains(childPid) else { continue }
-            visited.insert(childPid)
-            if let entry = processTable[childPid] {
-                result.append(entry)
-            }
-            if let grandchildren = childrenMap[childPid] {
-                queue.append(contentsOf: grandchildren)
-            }
-        }
-        return result
-    }
-
-    /// BFS descendants filtered to interesting commands only.
-    func interestingDescendants(of pid: Int) -> [ProcessEntry] {
-        descendants(of: pid).filter { ProcessQuery.interestingCommands.contains($0.comm) }
-    }
-
-    // MARK: - Enrichment
-
-    struct Enrichment {
-        let process: ProcessEntry
-        let tmuxSession: String?
-        let tmuxPaneId: String?
-        let windowId: UInt32?
-    }
-
-    /// Walk ppid chain from a process upward until we find a tmux pane_pid.
-    /// Returns (sessionName, paneId) or nil.
-    func tmuxLinkage(for entry: ProcessEntry) -> (session: String, paneId: String)? {
-        let paneLookup = buildPaneLookup()
-        var current = entry.pid
-        // Walk up at most 10 hops (typically 2-3)
-        for _ in 0..<10 {
-            if let match = paneLookup[current] {
-                return match
-            }
-            guard let parent = processTable[current]?.ppid, parent != current, parent > 1 else {
-                break
-            }
-            current = parent
-        }
-        return nil
-    }
-
-    /// Enrich a single process with tmux + window linkage.
-    func enrich(_ entry: ProcessEntry) -> Enrichment {
-        if let link = tmuxLinkage(for: entry) {
-            let win = DesktopModel.shared.windowForSession(link.session)
-            return Enrichment(
-                process: entry,
-                tmuxSession: link.session,
-                tmuxPaneId: link.paneId,
-                windowId: win?.wid
-            )
-        }
-        return Enrichment(process: entry, tmuxSession: nil, tmuxPaneId: nil, windowId: nil)
-    }
-
-    /// Enrich all interesting processes.
-    func enrichedProcesses() -> [Enrichment] {
-        interesting.map { enrich($0) }
-    }
-
-    // MARK: - Terminal Synthesis (on-demand)
-
-    /// Synthesize terminal instances on demand. Merges the current process table,
-    /// tmux sessions, terminal tabs (cached), and window list into a unified view.
-    /// Called by API endpoints — no background polling needed.
-    func synthesizeTerminals() -> [TerminalInstance] {
-        // Refresh tab cache if stale
-        let now = Date()
-        if now.timeIntervalSince(lastTabQueryTime) >= Self.tabCacheTTL {
-            cachedTerminalTabs = TerminalQuery.queryAll()
-            lastTabQueryTime = now
-        }
-
-        return TerminalSynthesizer.synthesize(
-            processTable: processTable,
-            interesting: interesting,
-            tmuxSessions: TmuxModel.shared.sessions,
-            terminalTabs: cachedTerminalTabs,
-            windows: DesktopModel.shared.windows
-        )
-    }
-
-    /// Force-refresh the terminal tab cache (e.g. on first query or explicit refresh).
-    func refreshTerminalTabs() {
-        cachedTerminalTabs = TerminalQuery.queryAll()
-        lastTabQueryTime = Date()
-    }
-
-    // MARK: - Polling (runs on pollQueue)
-
-    func poll() {
-        // 1. Full process snapshot
-        var table = ProcessQuery.snapshot()
-
-        // 2. Build parent → children map
-        var children: [Int: [Int]] = [:]
-        for (pid, entry) in table {
-            children[entry.ppid, default: []].append(pid)
-        }
-
-        // 3. Filter interesting, batch-resolve CWDs
-        let interestingEntries = ProcessQuery.filterInteresting(table)
-        let pids = interestingEntries.map(\.pid)
-        let cwds = ProcessQuery.batchCWD(pids: pids)
-
-        // 4. Merge CWDs back into table
-        for (pid, cwd) in cwds {
-            table[pid]?.cwd = cwd
-        }
-
-        let freshInteresting = pids.compactMap { table[$0] }
-        let freshPidSet = Set(pids)
-
-        // 5. Detect change
-        let changed = freshPidSet != lastInterestingPids
-
-        DispatchQueue.main.async {
-            self.processTable = table
-            self.childrenMap = children
-            self.interesting = freshInteresting
-        }
-
-        lastInterestingPids = freshPidSet
-
-        if changed {
-            EventBus.shared.post(.processesChanged(interesting: Array(freshPidSet)))
-        }
-    }
-
-    // MARK: - Private
-
-    /// Build [pane_pid: (sessionName, paneId)] from current TmuxModel state.
-    private func buildPaneLookup() -> [Int: (session: String, paneId: String)] {
-        var lookup: [Int: (session: String, paneId: String)] = [:]
-        for session in TmuxModel.shared.sessions {
-            for pane in session.panes {
-                lookup[pane.pid] = (session: session.name, paneId: pane.id)
-            }
-        }
-        return lookup
-    }
-}

package/app/Sources/ProcessQuery.swift

@@ -1,151 +0,0 @@
-import Foundation
-
-// MARK: - Data Models
-
-struct ProcessEntry {
-    let pid: Int
-    let ppid: Int
-    let pgid: Int
-    let tty: String        // "ttys003" or "??"
-    let comm: String       // basename, e.g. "node"
-    let args: String       // full command line
-    var cwd: String?       // filled by batchCWD
-}
-
-// MARK: - Query
-
-enum ProcessQuery {
-
-    /// Process names we care about for developer workspace enrichment
-    static let interestingCommands: Set<String> = [
-        "claude", "node", "bun", "deno", "python", "python3",
-        "ruby", "go", "cargo", "nvim", "vim", "npm", "npx",
-        "pnpm", "swift", "make", "git"
-    ]
-
-    /// Snapshot the full process table in a single `ps` call.
-    /// Returns [pid: ProcessEntry].
-    static func snapshot() -> [Int: ProcessEntry] {
-        let raw = shell([
-            "/bin/ps", "-eo", "pid,ppid,pgid,tty,comm,args"
-        ])
-        guard !raw.isEmpty else { return [:] }
-
-        var table: [Int: ProcessEntry] = [:]
-        let lines = raw.split(separator: "\n", omittingEmptySubsequences: true)
-
-        for line in lines.dropFirst() { // skip header
-            let str = String(line)
-            // Columns are whitespace-separated; args can contain spaces.
-            // Format: "  PID  PPID  PGID TTY      COMM             ARGS"
-            let trimmed = str.trimmingCharacters(in: .whitespaces)
-            let parts = trimmed.split(separator: " ", maxSplits: 5, omittingEmptySubsequences: true)
-            guard parts.count >= 6 else { continue }
-
-            guard let pid = Int(parts[0]),
-                  let ppid = Int(parts[1]),
-                  let pgid = Int(parts[2]) else { continue }
-
-            let tty = String(parts[3])
-            let commFull = String(parts[4])
-            let args = String(parts[5])
-
-            // comm from ps is the full path; take basename
-            let comm = (commFull as NSString).lastPathComponent
-
-            table[pid] = ProcessEntry(
-                pid: pid, ppid: ppid, pgid: pgid,
-                tty: tty, comm: comm, args: args, cwd: nil
-            )
-        }
-
-        return table
-    }
-
-    /// Batch-resolve working directories for a set of PIDs via a single `lsof` call.
-    /// Returns [pid: cwdPath].
-    static func batchCWD(pids: [Int]) -> [Int: String] {
-        guard !pids.isEmpty else { return [:] }
-
-        let pidList = pids.map(String.init).joined(separator: ",")
-        let raw = shell([
-            "/usr/sbin/lsof", "-a", "-d", "cwd", "-p", pidList, "-Fn"
-        ])
-        guard !raw.isEmpty else { return [:] }
-
-        var result: [Int: String] = [:]
-        var currentPid: Int?
-
-        for line in raw.split(separator: "\n", omittingEmptySubsequences: true) {
-            let s = String(line)
-            if s.hasPrefix("p") {
-                currentPid = Int(s.dropFirst())
-            } else if s.hasPrefix("n"), let pid = currentPid {
-                result[pid] = String(s.dropFirst())
-            }
-        }
-
-        return result
-    }
-
-    /// Filter a process table down to interesting developer processes.
-    static func filterInteresting(_ table: [Int: ProcessEntry]) -> [ProcessEntry] {
-        table.values.filter { interestingCommands.contains($0.comm) }
-    }
-
-    // MARK: - Shell helper
-
-    /// Run a command and capture stdout using posix_spawn + waitpid.
-    /// Avoids Process/NSTask's waitUntilExit() which deadlocks on macOS 26
-    /// when called from GUI apps (CFRunLoop issue).
-    static func shell(_ args: [String]) -> String {
-        // Set up stdout pipe
-        var pipeFds: [Int32] = [0, 0]
-        guard pipe(&pipeFds) == 0 else { return "" }
-
-        // File actions: stdout → write end of pipe, stderr → /dev/null
-        var fileActions: posix_spawn_file_actions_t?
-        posix_spawn_file_actions_init(&fileActions)
-        posix_spawn_file_actions_adddup2(&fileActions, pipeFds[1], STDOUT_FILENO)
-        posix_spawn_file_actions_addopen(&fileActions, STDERR_FILENO, "/dev/null", O_WRONLY, 0)
-        posix_spawn_file_actions_addclose(&fileActions, pipeFds[0])
-        posix_spawn_file_actions_addclose(&fileActions, pipeFds[1])
-
-        // Build C strings
-        let cPath = args[0]
-        let cArgs = args.map { strdup($0) } + [nil]
-        defer { cArgs.compactMap({ $0 }).forEach { free($0) } }
-
-        var pid: pid_t = 0
-        let spawnResult = cPath.withCString { path in
-            posix_spawn(&pid, path, &fileActions, nil, cArgs, environ)
-        }
-        posix_spawn_file_actions_destroy(&fileActions)
-
-        // Close write end in parent
-        close(pipeFds[1])
-
-        guard spawnResult == 0 else {
-            close(pipeFds[0])
-            return ""
-        }
-
-        // Read all stdout
-        var data = Data()
-        let bufSize = 65536
-        var buf = [UInt8](repeating: 0, count: bufSize)
-        while true {
-            let n = read(pipeFds[0], &buf, bufSize)
-            if n <= 0 { break }
-            data.append(buf, count: n)
-        }
-        close(pipeFds[0])
-
-        // Wait for child
-        var status: Int32 = 0
-        waitpid(pid, &status, 0)
-
-        guard status == 0 else { return "" }
-        return String(data: data, encoding: .utf8)?.trimmingCharacters(in: .whitespacesAndNewlines) ?? ""
-    }
-}

package/app/Sources/Project.swift

@@ -1,28 +0,0 @@
-import CryptoKit
-import Foundation
-
-struct Project: Identifiable {
-    let id: String
-    let path: String
-    let name: String
-    let devCommand: String?
-    let packageManager: String?
-    let hasConfig: Bool
-    let paneCount: Int
-    let paneNames: [String]
-    let paneSummary: String
-    var isRunning: Bool
-
-    /// Unique session name: basename-{6-char SHA256 hash of full path}
-    /// Must match the JS `toSessionName()` in lattices.js exactly
-    var sessionName: String {
-        let base = name.replacingOccurrences(
-            of: "[^a-zA-Z0-9_-]",
-            with: "-",
-            options: .regularExpression
-        )
-        let hash = SHA256.hash(data: Data(path.utf8))
-        let short = hash.prefix(3).map { String(format: "%02x", $0) }.joined()
-        return "\(base)-\(short)"
-    }
-}