@lattices/cli 0.3.0 → 0.4.0

package/app/Sources/Intents/CreateLayerIntent.swift

@@ -0,0 +1,54 @@
+import Foundation
+
+struct CreateLayerIntent: LatticeIntent {
+    static let name = "create_layer"
+    static let title = "Save the current layout as a named layer"
+
+    static let phrases = [
+        // create
+        "create a layer called {name}",
+        "create layer called {name}",
+        "create a layer {name}",
+        "create layer {name}",
+        "create new layer {name}",
+        // make
+        "make a layer called {name}",
+        "make layer called {name}",
+        "make a layer {name}",
+        "make layer {name}",
+        "make a new layer {name}",
+        // save
+        "save this layout as {name}",
+        "save layout as {name}",
+        "save as layer {name}",
+        "save as {name}",
+        // name / snapshot
+        "name this layer {name}",
+        "new layer called {name}",
+        "new layer {name}",
+        // No-arg variants
+        "create a layer",
+        "create layer",
+        "save this layout",
+        "save layout",
+        "snapshot",
+        "snapshot this",
+        "remember this layout",
+        "save this workspace",
+    ]
+
+    static let slots = [
+        SlotDef(name: "name", type: .string, required: false),
+    ]
+
+    func perform(slots: [String: JSON]) throws -> JSON {
+        var params: [String: JSON] = [:]
+        if let name = slots["name"]?.stringValue {
+            params["name"] = .string(name)
+        }
+        return try LatticesApi.shared.dispatch(
+            method: "layer.create",
+            params: .object(params)
+        )
+    }
+}

package/app/Sources/Intents/DistributeIntent.swift

@@ -0,0 +1,56 @@
+import Foundation
+
+struct DistributeIntent: LatticeIntent {
+    static let name = "distribute"
+    static let title = "Distribute windows evenly across the screen"
+
+    static let phrases = [
+        // Primary: spread / distribute
+        "distribute",
+        "distribute windows",
+        "distribute everything",
+        "spread",
+        "spread out",
+        "spread out the windows",
+        "spread them out",
+        // organize / arrange
+        "organize",
+        "organize windows",
+        "organize my windows",
+        "organize everything",
+        "arrange",
+        "arrange windows",
+        "arrange my windows",
+        "arrange everything",
+        "arrange them evenly",
+        // tidy / clean
+        "tidy",
+        "tidy up",
+        "tidy up the desktop",
+        "tidy up my windows",
+        "clean up",
+        "clean up the layout",
+        "clean up my desktop",
+        // other
+        "even out",
+        "even out the windows",
+        "fix the layout",
+        "reset the layout",
+        "make a grid",
+        "grid layout",
+        "line them up",
+        "line everything up",
+        "get everything organized",
+        "clean up the windows",
+        "clean up windows",
+    ]
+
+    static let slots: [SlotDef] = []
+
+    func perform(slots: [String: JSON]) throws -> JSON {
+        DispatchQueue.main.async {
+            WindowTiler.distributeVisible()
+        }
+        return .object(["ok": .bool(true)])
+    }
+}

package/app/Sources/Intents/FocusIntent.swift

@@ -0,0 +1,69 @@
+import Foundation
+
+struct FocusIntent: LatticeIntent {
+    static let name = "focus"
+    static let title = "Focus and raise a window"
+
+    static let phrases = [
+        // Primary operator: show
+        "show {app}",
+        "show me {app}",
+        "show me the {app}",
+        // focus
+        "focus {app}",
+        "focus on {app}",
+        "focus the {app}",
+        // switch / go
+        "switch to {app}",
+        "switch over to {app}",
+        "go to {app}",
+        "go back to {app}",
+        // bring / raise / pull
+        "bring up {app}",
+        "bring up the {app}",
+        "bring forward {app}",
+        "raise {app}",
+        "raise the {app}",
+        "pull up {app}",
+        "pull up the {app}",
+        // natural
+        "i want to see {app}",
+        "let me see {app}",
+        "take me to {app}",
+        "give me {app}",
+        "give me the {app}",
+        // activate / jump
+        "activate {app}",
+        "activate the {app}",
+        "jump to {app}",
+    ]
+
+    static let slots = [
+        SlotDef(name: "app", type: .app, required: true),
+    ]
+
+    func perform(slots: [String: JSON]) throws -> JSON {
+        guard let app = slots["app"]?.stringValue else {
+            throw IntentError.missingSlot("app")
+        }
+
+        // Use unified search — single source of truth
+        let result = try LatticesApi.shared.dispatch(
+            method: "lattices.search",
+            params: .object([
+                "query": .string(app),
+                "sources": .array([.string("titles"), .string("apps"), .string("sessions"), .string("cwd"), .string("tmux")]),
+            ])
+        )
+        if case .array(let items) = result, let first = items.first,
+           let wid = first["wid"]?.uint32Value {
+            let pid = first["pid"]?.intValue ?? Int(DesktopModel.shared.windows[wid]?.pid ?? 0)
+            DispatchQueue.main.async {
+                WindowTiler.focusWindow(wid: wid, pid: Int32(pid))
+            }
+            return .object(["ok": .bool(true), "focused": .string(app), "wid": .int(Int(wid))])
+        }
+
+        return .object(["ok": .bool(false), "reason": .string("No window found for '\(app)'")])
+    }
+}

package/app/Sources/Intents/HelpIntent.swift

@@ -0,0 +1,41 @@
+import Foundation
+
+struct HelpIntent: LatticeIntent {
+    static let name = "help"
+    static let title = "Show available commands and usage"
+
+    static let phrases = [
+        "help",
+        "help me",
+        "what can i do",
+        "what can you do",
+        "what commands are there",
+        "what are the commands",
+        "how does this work",
+        "how do i use this",
+        "show me the commands",
+        "what can i say",
+        "what are my options",
+    ]
+
+    static let slots: [SlotDef] = []
+
+    func perform(slots: [String: JSON]) throws -> JSON {
+        let commands = [
+            "find <query> — search windows by name, title, or content",
+            "show <app> — focus an app window",
+            "open <project> — launch a project or app",
+            "tile <position> — tile the current window (left, right, top-left, etc.)",
+            "maximize — make the current window full screen",
+            "distribute — arrange all visible windows in a grid",
+            "scan — OCR all visible windows",
+            "kill <session> — stop a tmux session",
+            "list windows — show all open windows",
+            "list sessions — show running tmux sessions",
+        ]
+        return .object([
+            "commands": .array(commands.map { .string($0) }),
+            "hint": .string("You can also say things naturally — 'where's my Slack?' or 'tidy up the windows'"),
+        ])
+    }
+}

package/app/Sources/Intents/KillIntent.swift

@@ -0,0 +1,47 @@
+import Foundation
+
+struct KillIntent: LatticeIntent {
+    static let name = "kill"
+    static let title = "Stop a running session"
+
+    static let phrases = [
+        // Primary operator: kill
+        "kill {session}",
+        "kill the {session}",
+        "kill the {session} session",
+        "kill that",
+        // stop
+        "stop {session}",
+        "stop the {session}",
+        "stop the {session} session",
+        // shut down
+        "shut down {session}",
+        "shut down the {session}",
+        "shut it down",
+        // close
+        "close {session}",
+        "close the {session}",
+        "close the {session} session",
+        // terminate
+        "terminate {session}",
+        "terminate the {session}",
+        // end
+        "end {session}",
+        "end the {session}",
+        "end the {session} session",
+    ]
+
+    static let slots = [
+        SlotDef(name: "session", type: .session, required: true),
+    ]
+
+    func perform(slots: [String: JSON]) throws -> JSON {
+        guard let session = slots["session"]?.stringValue else {
+            throw IntentError.missingSlot("session")
+        }
+        return try LatticesApi.shared.dispatch(
+            method: "session.kill",
+            params: .object(["name": .string(session)])
+        )
+    }
+}

package/app/Sources/Intents/LatticeIntent.swift

@@ -0,0 +1,78 @@
+import Foundation
+
+// MARK: - Core Protocol
+
+/// A self-contained voice intent. Each intent declares its phrases, slots, and execution.
+protocol LatticeIntent {
+    static var name: String { get }
+    static var title: String { get }
+    static var phrases: [String] { get }       // e.g. "find {query}", "search for {query}"
+    static var slots: [SlotDef] { get }
+
+    func perform(slots: [String: JSON]) throws -> JSON
+}
+
+// MARK: - Slot Definition
+
+enum SlotType {
+    case string                           // Free-form text
+    case position                         // Tile position (left, right, maximize, etc.)
+    case app                              // Running app name
+    case session                          // Active tmux session
+    case layer                            // Layer name
+    case enumerated([String])             // Fixed set of values
+}
+
+struct SlotDef {
+    let name: String
+    let type: SlotType
+    let required: Bool
+    let defaultValue: JSON?
+
+    init(name: String, type: SlotType, required: Bool = true, defaultValue: JSON? = nil) {
+        self.name = name
+        self.type = type
+        self.required = required
+        self.defaultValue = defaultValue
+    }
+}
+
+// MARK: - Compiled Phrase Template
+
+struct CompiledPhrase {
+    let original: String                  // "find {query}"
+    let regex: NSRegularExpression        // ^find (.+)$
+    let slotNames: [String]              // ["query"] in capture-group order
+    let intentName: String
+}
+
+// MARK: - Match Result
+
+struct IntentMatch {
+    let intentName: String
+    let slots: [String: JSON]
+    let confidence: Double
+    let matchedPhrase: String
+}
+
+// MARK: - Phrase Matcher
+
+final class PhraseMatcher {
+    static let shared = PhraseMatcher()
+
+    private init() {
+        DiagnosticLog.shared.info("PhraseMatcher: semantic resolver active (\(IntentEngine.shared.definitions().count) intents)")
+    }
+
+    func match(text: String) -> IntentMatch? {
+        VoiceIntentResolver.shared.match(text: text)
+    }
+
+    func execute(_ match: IntentMatch) throws -> JSON {
+        try VoiceIntentResolver.shared.execute(match)
+    }
+
+    func catalog() -> JSON {
+        VoiceIntentResolver.shared.catalog()
+    }
+}

package/app/Sources/Intents/LaunchIntent.swift

@@ -0,0 +1,67 @@
+import AppKit
+import Foundation
+
+struct LaunchIntent: LatticeIntent {
+    static let name = "launch"
+    static let title = "Launch a project or app"
+
+    static let phrases = [
+        // Primary operator: open
+        "open {project}",
+        "open up {project}",
+        "open my {project}",
+        "open the {project}",
+        // launch
+        "launch {project}",
+        "launch the {project}",
+        "launch my {project}",
+        // start
+        "start {project}",
+        "start up {project}",
+        "start the {project}",
+        "start my {project}",
+        "start working on {project}",
+        // work on
+        "work on {project}",
+        "work on the {project}",
+        "begin {project}",
+        "begin working on {project}",
+        // fire / spin / boot
+        "fire up {project}",
+        "spin up {project}",
+        "boot up {project}",
+        // load / run
+        "load {project}",
+        "load up {project}",
+        "run {project}",
+        "run the {project}",
+    ]
+
+    static let slots = [
+        SlotDef(name: "project", type: .string, required: true),
+    ]
+
+    func perform(slots: [String: JSON]) throws -> JSON {
+        guard let project = slots["project"]?.stringValue else {
+            throw IntentError.missingSlot("project")
+        }
+
+        // Try to find the project by scanning known project paths
+        let scanner = ProjectScanner.shared
+        if let found = scanner.projects.first(where: {
+            $0.name.lowercased().contains(project.lowercased())
+        }) {
+            // Launch via session manager
+            let result = try LatticesApi.shared.dispatch(
+                method: "session.launch",
+                params: .object(["path": .string(found.path)])
+            )
+            return result
+        }
+
+        // Fallback: try as an app name
+        let app = project.prefix(1).uppercased() + project.dropFirst()
+        NSWorkspace.shared.launchApplication(app)
+        return .object(["ok": .bool(true), "launched": .string(app)])
+    }
+}

package/app/Sources/Intents/ListSessionsIntent.swift

@@ -0,0 +1,32 @@
+import Foundation
+
+struct ListSessionsIntent: LatticeIntent {
+    static let name = "list_sessions"
+    static let title = "List running tmux sessions"
+
+    static let phrases = [
+        "list sessions",
+        "list all sessions",
+        "list my sessions",
+        "what sessions",
+        "what sessions are running",
+        "what's running",
+        "whats running",
+        "what is running",
+        "which projects",
+        "which projects are active",
+        "show sessions",
+        "show my sessions",
+        "show my projects",
+        "show me what's running",
+        "show me whats running",
+        "how many sessions",
+        "any sessions running",
+    ]
+
+    static let slots: [SlotDef] = []
+
+    func perform(slots: [String: JSON]) throws -> JSON {
+        try LatticesApi.shared.dispatch(method: "sessions.list", params: nil)
+    }
+}

package/app/Sources/Intents/ListWindowsIntent.swift

@@ -0,0 +1,30 @@
+import Foundation
+
+struct ListWindowsIntent: LatticeIntent {
+    static let name = "list_windows"
+    static let title = "List all open windows"
+
+    static let phrases = [
+        "list windows",
+        "list all windows",
+        "list my windows",
+        "what windows",
+        "what windows are open",
+        "what's open",
+        "which windows",
+        "which windows are visible",
+        "show all windows",
+        "show me all windows",
+        "show me all the windows",
+        "how many windows",
+        "count windows",
+        "what do i have open",
+        "what's visible",
+    ]
+
+    static let slots: [SlotDef] = []
+
+    func perform(slots: [String: JSON]) throws -> JSON {
+        try LatticesApi.shared.dispatch(method: "windows.list", params: nil)
+    }
+}

package/app/Sources/Intents/ScanIntent.swift

@@ -0,0 +1,52 @@
+import Foundation
+
+struct ScanIntent: LatticeIntent {
+    static let name = "scan"
+    static let title = "Rescan screen text (OCR)"
+
+    static let phrases = [
+        // Primary operator: scan
+        "scan",
+        "scan the screen",
+        "scan everything",
+        "scan all",
+        "scan my screen",
+        "scan my windows",
+        "scan all windows",
+        // rescan
+        "rescan",
+        "rescan the screen",
+        "rescan everything",
+        // read
+        "read the screen",
+        "read my screen",
+        "read all windows",
+        // ocr
+        "ocr",
+        "ocr scan",
+        "run ocr",
+        // update / refresh / capture
+        "update screen text",
+        "refresh screen text",
+        "capture screen text",
+        "capture text",
+        // natural
+        "what's on my screen",
+        "what's on screen",
+        "what is on my screen",
+        "show me what's on the screen",
+        "show me what is on the screen",
+        "index the screen",
+        "do a scan",
+        "give me a scan",
+        "give me a fresh scan",
+        "quick scan",
+        "a fresh scan",
+    ]
+
+    static let slots: [SlotDef] = []
+
+    func perform(slots: [String: JSON]) throws -> JSON {
+        try LatticesApi.shared.dispatch(method: "ocr.scan", params: nil)
+    }
+}