@lattices/cli 0.4.13 → 0.5.0

package/apps/mac/Sources/Core/Actions/IntentSchema.swift

@@ -1,94 +0,0 @@
-import Foundation
-
-struct IntentDef {
-    let name: String
-    let description: String
-    let examples: [String]
-    let slots: [IntentSlot]
-    let handler: (IntentRequest) throws -> JSON
-}
-
-struct IntentSlot {
-    let name: String
-    let type: String
-    let required: Bool
-    let description: String
-    let enumValues: [String]?
-    let defaultValue: JSON?
-
-    init(
-        name: String,
-        type: String,
-        required: Bool,
-        description: String,
-        enumValues: [String]? = nil,
-        defaultValue: JSON? = nil
-    ) {
-        self.name = name
-        self.type = type
-        self.required = required
-        self.description = description
-        self.enumValues = enumValues
-        self.defaultValue = defaultValue
-    }
-}
-
-struct IntentRequest {
-    let intent: String
-    let slots: [String: JSON]
-    let rawText: String?
-    let confidence: Double?
-    let source: String?
-}
-
-enum SlotType {
-    case string
-    case int
-    case bool
-    case position
-    case query
-    case app
-    case session
-    case layer
-    case enumerated([String])
-
-    var typeLabel: String {
-        switch self {
-        case .string: return "string"
-        case .int: return "int"
-        case .bool: return "bool"
-        case .position: return "position"
-        case .query: return "query"
-        case .app: return "app"
-        case .session: return "session"
-        case .layer: return "layer"
-        case .enumerated: return "string"
-        }
-    }
-
-    var enumValues: [String]? {
-        guard case .enumerated(let values) = self else { return nil }
-        return values
-    }
-}
-
-typealias SlotDef = IntentSlot
-
-extension IntentSlot {
-    init(
-        name: String,
-        type: SlotType,
-        required: Bool = true,
-        description: String = "",
-        defaultValue: JSON? = nil
-    ) {
-        self.init(
-            name: name,
-            type: type.typeLabel,
-            required: required,
-            description: description,
-            enumValues: type.enumValues,
-            defaultValue: defaultValue
-        )
-    }
-}

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

@@ -1,54 +0,0 @@
-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/apps/mac/Sources/Core/Actions/Intents/DistributeIntent.swift

@@ -1,56 +0,0 @@
-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/apps/mac/Sources/Core/Actions/Intents/FocusIntent.swift

@@ -1,69 +0,0 @@
-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/apps/mac/Sources/Core/Actions/Intents/HelpIntent.swift

@@ -1,41 +0,0 @@
-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/apps/mac/Sources/Core/Actions/Intents/KillIntent.swift

@@ -1,47 +0,0 @@
-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/apps/mac/Sources/Core/Actions/Intents/LatticeIntent.swift

@@ -1,53 +0,0 @@
-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: - 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/apps/mac/Sources/Core/Actions/Intents/LaunchIntent.swift

@@ -1,67 +0,0 @@
-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/apps/mac/Sources/Core/Actions/Intents/ListSessionsIntent.swift

@@ -1,32 +0,0 @@
-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/apps/mac/Sources/Core/Actions/Intents/ListWindowsIntent.swift

@@ -1,30 +0,0 @@
-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/apps/mac/Sources/Core/Actions/Intents/ScanIntent.swift

@@ -1,52 +0,0 @@
-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)
-    }
-}