@lattices/cli 0.4.14 → 0.6.0

package/apps/mac/Sources/Core/Actions/Intents/SearchIntent.swift

@@ -1,190 +0,0 @@
-import Foundation
-
-struct SearchIntent: LatticeIntent {
-    static let name = "search"
-    static let title = "Find windows by name, title, or content"
-
-    static let phrases = [
-        // Primary operator: find
-        "find {query}",
-        "find all {query}",
-        "find all the {query}",
-        // search
-        "search {query}",
-        "search for {query}",
-        "search for all {query}",
-        // look for
-        "look for {query}",
-        "look up {query}",
-        // where
-        "where is {query}",
-        "where's {query}",
-        "where does it say {query}",
-        "where did i see {query}",
-        // which / can you
-        "which window has {query}",
-        "which window shows {query}",
-        "can you find {query}",
-        "help me find {query}",
-        // locate
-        "locate {query}",
-        "locate all {query}",
-        // "open up all the X windows" = find, not launch
-        "open up all the {query} windows",
-        "open up all {query} windows",
-        "open all the {query} windows",
-        "open all {query} windows",
-        "show me all the {query} windows",
-        "show me all {query} windows",
-        "show all the {query} windows",
-        "show all {query} windows",
-        // "pull up" = find/focus
-        "pull up {query}",
-        "pull up all {query}",
-        "pull up everything with {query} in it",
-        "bring up all the {query}",
-        "bring up all {query}",
-        // show me (without "windows" suffix)
-        "show me all the {query}",
-        "show me all {query}",
-        "show me the {query}",
-        "show me {query}",
-        "show all the {query}",
-        "show all {query}",
-        // get
-        "get {query}",
-        "get all {query}",
-        "get all the {query}",
-        "get me {query}",
-        "get me all the {query}",
-        // give me
-        "give me all the {query}",
-        "give me all {query}",
-        "give me {query}",
-        // list
-        "list {query}",
-        "list all {query}",
-        "list all the {query}",
-        // Casual / natural
-        "where'd my {query} go",
-        "where'd {query} go",
-        "i lost my {query}",
-        "i lost {query}",
-        "where the hell is {query}",
-        "get {query} on screen",
-        "{query} windows",
-    ]
-
-    static let slots = [
-        SlotDef(name: "query", type: .string, required: true),
-    ]
-
-    /// Expand natural-language terms into search-friendly queries.
-    /// e.g. "terminals" → ["terminals", "iterm", "terminal", "warp", "kitty", "alacritty"]
-    private static let synonyms: [String: [String]] = [
-        "terminals": ["iterm", "terminal", "warp", "kitty", "alacritty", "hyper"],
-        "terminal": ["iterm", "terminal", "warp", "kitty", "alacritty", "hyper"],
-        "browsers": ["safari", "chrome", "firefox", "arc", "brave", "edge"],
-        "browser": ["safari", "chrome", "firefox", "arc", "brave", "edge"],
-        "editors": ["code", "cursor", "xcode", "vim", "neovim", "zed", "sublime"],
-        "editor": ["code", "cursor", "xcode", "vim", "neovim", "zed", "sublime"],
-        "chat": ["slack", "discord", "messages", "telegram", "whatsapp"],
-        "music": ["spotify", "music", "apple music"],
-        "mail": ["mail", "gmail", "outlook", "spark"],
-        "notes": ["notes", "obsidian", "notion", "bear"],
-    ]
-
-    /// Clean up a voice query: strip filler phrases, qualifiers, and noise.
-    private static func cleanQuery(_ raw: String) -> String {
-        var q = raw.lowercased().trimmingCharacters(in: .whitespaces)
-
-        // Strip trailing qualifiers ("and sort by ...", "sorted by ...", "ordered by ...")
-        for pattern in [" and sort", " and order", " sorted by", " ordered by",
-                        " and filter", " and group", " and show", " and list",
-                        " please", " for me"] {
-            if let range = q.range(of: pattern) {
-                q = String(q[q.startIndex..<range.lowerBound])
-            }
-        }
-
-        // Strip trailing "windows"/"apps"
-        for suffix in [" windows", " apps", " applications"] {
-            if q.hasSuffix(suffix) {
-                q = String(q.dropLast(suffix.count))
-                break
-            }
-        }
-
-        return q.trimmingCharacters(in: .whitespaces)
-    }
-
-    func perform(slots: [String: JSON]) throws -> JSON {
-        guard let rawQuery = slots["query"]?.stringValue, !rawQuery.isEmpty else {
-            throw IntentError.missingSlot("query")
-        }
-
-        let queryLower = Self.cleanQuery(rawQuery)
-        guard !queryLower.isEmpty else {
-            throw IntentError.missingSlot("query")
-        }
-
-        if queryLower != rawQuery.lowercased().trimmingCharacters(in: .whitespaces) {
-            DiagnosticLog.shared.info("search: cleaned '\(rawQuery)' → '\(queryLower)'")
-        }
-
-        // Check for synonym expansion (e.g. "terminals" → ["iterm", "terminal", ...])
-        if let expansions = Self.synonyms[queryLower] {
-            DiagnosticLog.shared.info("search: query='\(rawQuery)' → expanding to \(expansions)")
-            return try searchExpanded(queries: expansions)
-        }
-
-        DiagnosticLog.shared.info("search: query='\(queryLower)'")
-        return try searchSingle(query: queryLower)
-    }
-
-    private func searchSingle(query: String) throws -> JSON {
-        // Quick first — title, app, session, OCR (instant)
-        let quick = try LatticesApi.shared.dispatch(
-            method: "lattices.search",
-            params: .object(["query": .string(query), "mode": .string("quick")])
-        )
-        if case .array(let items) = quick, !items.isEmpty {
-            DiagnosticLog.shared.info("search: \(items.count) results for '\(query)' (quick)")
-            return quick
-        }
-
-        // Escalate to complete — adds terminal cwd/processes + OCR
-        let result = try LatticesApi.shared.dispatch(
-            method: "lattices.search",
-            params: .object(["query": .string(query)])
-        )
-        if case .array(let items) = result {
-            DiagnosticLog.shared.info("search: \(items.count) results for '\(query)' (complete)")
-        }
-        return result
-    }
-
-    /// Search for multiple expanded queries and deduplicate by window ID.
-    private func searchExpanded(queries: [String]) throws -> JSON {
-        var seenWids: Set<Int> = []
-        var merged: [JSON] = []
-
-        for q in queries {
-            let result = try LatticesApi.shared.dispatch(
-                method: "lattices.search",
-                params: .object(["query": .string(q), "mode": .string("quick")])
-            )
-            if case .array(let items) = result {
-                for item in items {
-                    if let wid = item["wid"]?.intValue, !seenWids.contains(wid) {
-                        seenWids.insert(wid)
-                        merged.append(item)
-                    }
-                }
-            }
-        }
-
-        DiagnosticLog.shared.info("search: \(merged.count) results from expanded search")
-        return .array(merged)
-    }
-}

package/apps/mac/Sources/Core/Actions/Intents/SwitchLayerIntent.swift

@@ -1,50 +0,0 @@
-import Foundation
-
-struct SwitchLayerIntent: LatticeIntent {
-    static let name = "switch_layer"
-    static let title = "Switch to a workspace layer"
-
-    static let phrases = [
-        // Primary: layer
-        "layer {layer}",
-        // switch to
-        "switch to layer {layer}",
-        "switch to the {layer} layer",
-        "switch to {layer}",
-        // go to
-        "go to layer {layer}",
-        "go to the {layer} layer",
-        "go to {layer} layer",
-        // activate / change
-        "activate layer {layer}",
-        "activate the {layer} layer",
-        "change to layer {layer}",
-        "change layer to {layer}",
-        // numbered
-        "layer one",
-        "layer two",
-        "layer three",
-        "layer 1",
-        "layer 2",
-        "layer 3",
-        "first layer",
-        "second layer",
-        "third layer",
-        "next layer",
-        "previous layer",
-    ]
-
-    static let slots = [
-        SlotDef(name: "layer", type: .layer, required: true),
-    ]
-
-    func perform(slots: [String: JSON]) throws -> JSON {
-        guard let layer = slots["layer"]?.stringValue else {
-            throw IntentError.missingSlot("layer")
-        }
-        return try LatticesApi.shared.dispatch(
-            method: "layer.switch",
-            params: .object(["name": .string(layer)])
-        )
-    }
-}

package/apps/mac/Sources/Core/Actions/Intents/TileIntent.swift

@@ -1,61 +0,0 @@
-import Foundation
-
-struct TileIntent: LatticeIntent {
-    static let name = "tile_window"
-    static let title = "Tile a window to a screen position"
-
-    static let phrases = [
-        // Primary operator: tile
-        "tile {position}",
-        "tile it {position}",
-        "tile this {position}",
-        "tile the window {position}",
-        // snap
-        "snap {position}",
-        "snap it {position}",
-        "snap to the {position}",
-        "snap to {position}",
-        // move / put
-        "move to the {position}",
-        "move it to the {position}",
-        "move it {position}",
-        "move this to the {position}",
-        "move this over to the {position}",
-        "put it on the {position}",
-        "put this on the {position}",
-        "put it on the {position} side",
-        "put this on the {position} side",
-        "put it {position}",
-        "throw it {position}",
-        "throw it to the {position}",
-        "just put it on the {position}",
-        // Standalone position phrases
-        "{position} half",
-        "{position} side",
-        // maximize variants (no slot needed — position is the whole phrase)
-        "maximize",
-        "maximize it",
-        "make it full screen",
-        "full screen",
-        "go full screen",
-        "make it big",
-        "center it",
-        "center the window",
-    ]
-
-    static let slots = [
-        SlotDef(name: "position", type: .position, required: true, defaultValue: .string("center")),
-    ]
-
-    func perform(slots: [String: JSON]) throws -> JSON {
-        let posName = slots["position"]?.stringValue ?? "center"
-        guard let placement = PlacementSpec(string: posName) else {
-            return .object(["ok": .bool(false), "reason": .string("Unknown position '\(posName)'")])
-        }
-
-        DispatchQueue.main.async {
-            WindowTiler.tileFrontmostViaAX(to: placement)
-        }
-        return .object(["ok": .bool(true), "position": .string(posName)])
-    }
-}